Bitcoin puzzle transaction ~32 BTC prize to who solves it

[bestie1549]

I really appreciate your advice, yeah i was just wondering if i could try my luck with all the unsolved addresses at once lmao.

If anyone can correct me with this:
Since Puzzle 64 was found 2022-09-10
does that mean it's been a year now 2023-09-20 and still the search for Puzzle 66 on going?!

if you do your math well
the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years
now we have pools that are scanning and they're barely 4% gone on the 66 bit range...
so this is to tell you that you should expect at least another 1 or 2 more years for the 66 bit range to be defeated successfully
but the pubkey ranges might be the appropriate range of choice for you as these gets defeated almost every 4 to 6 months

[1714634339]

1714634339

[1714634339]

1714634339

[1714634339]

1714634339

[digaran]

if you do your math well
the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years

How did you calculate to get 500 years? An average cpu is useless, with a good GPU you could get 1 billion keys per second which would take 2339 years to search the entire 66 bit range, even if we divide that time by half, we get 1169 years with an average GPU. If you run 1000 GPUs each at 1B/s for more than 14 months, you could search half the range of 2^66, if the key is not there, you'd need to keep searching, in total to make sure 66 bit is searched completely, 28 months running 1000 GPUs, nonstop.

Also addresses with revealed pubs are not solvable every 4 to 6 month, if you are using kangaroo, it will get more difficult as each key range is 32 times larger than the previous key range, unless you know some tricks to reduce this range, otherwise you should at least multiply the time by 8, so if 125 took 4 months, 130 should take around 32 months. Then even if we double that time, we can expect 135 to take at least 64 months.


Note, my calculations are estimates.

[citb0in]

Since Puzzle 64 was found 2022-09-10
does that mean it's been a year now 2023-09-20 and still the search for Puzzle 66 on going?!

puzzle #64 was found on 2022-09-09
puzzle #65 was found already on 2019-06-07
puzzle #120 was found on 2023-02-27 but the privkey was not revealed yet

correct, puzzle #66 is still ongoing ...

[nomachine]

if you do your math well
the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years

28 months running 1000 GPUs, nonstop.

Imagine that electricity bill at the household rate.

[digaran]

if you do your math well
the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years

28 months running 1000 GPUs, nonstop.

Imagine that electricity bill at the household rate.

Ok then, lets materialize our imagination, if we want to be fair, we should say the time taken to solve 66 is 14 month and not 28 month. Right?

14 month = 420 days.
420 days = 10080 hours.
RTX 3090 rental price = $0.20/hr
1 RTX 3090 rented for 10080 hours = $2016
1000 RTX 3090 rented for 10080 hours = $2016000
We will use a discounted price of $2,000,000 USD.

Puzzle 66 contains 6.6 bitcoins, at a price of $30,000. 6.6 * 30,000 = $198000.

In the future when bitcoin is at $100,000 * 6.6 = $660,000.
Further in the future, bitcoin is at $300,000. tech has advanced, speed of key per second is now 10B/s. So we just need 100 GPUs.
100 * $2016 = $201,600. With discount is $200,000 cost of finding #66, and bitcoin at 300k, now puzzle reward is worth $1,980,000 - 200,000 = $1,780,000 profit.

Question, when will we see GPU speed jumping from 1B/s to 10B/s, and bitcoin price at $300,000?
Even then what about #67, two times harder than #66 in theory, #68, #69, #70?

It's either profitable to rent GPUs and find them, or will be profitable in the future, in both cases, nothing really changes, nobody is gonna come up with a solution and an algorithm to brute force keys with 10B/s rate in the next 10 years.

[nomachine]

Script above is the python version of your code written in alien language, I'm on phone so I couldn't test to see if it works, later I will test it on my laptop and fix any issues. Insha'Allah. ( God willing )

Also;
Thanks for the update on the code, appreciate it. My scripts ( small part of them ) don't need much speed because they are not supposed to auto solve a key, they are intended as learning tools, I talked about improving performance to make king of information stop whining so much. 🤣

I use GMP even for random number generation..I'm playing around with collisions and cycles now.  

Code:

import sys
import os
import time
import gmpy2
from gmpy2 import mpz
from functools import lru_cache
import secp256k1 as ice
import multiprocessing
from multiprocessing import Pool, cpu_count

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

# Define Point class
class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

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

# Function to multiply a point by 2
@lru_cache(maxsize=None)
def multiply_by_2(P, p=MODULO):
    c = gmpy2.f_mod(3 * P.x * P.x * gmpy2.powmod(2 * P.y, -1, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - 2 * P.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to add two points
@lru_cache(maxsize=None)
def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dy = Q.y - P.y
    c = gmpy2.f_mod(dy * gmpy2.invert(dx, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - P.x - Q.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to calculate Y-coordinate from X-coordinate
@lru_cache(maxsize=None)
def x_to_y(X, y_parity, p=MODULO):
    Y = gmpy2.mpz(3)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    X = gmpy2.f_mod(tmp + 7, p)

    Y = gmpy2.f_div(gmpy2.add(p, 1), 4)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    Y = tmp

    if Y % 2 != y_parity:
        Y = gmpy2.f_mod(-Y, p)

    return Y

# Function to compute a table of points
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()

# Global event to signal all processes to stop
STOP_EVENT = multiprocessing.Event()

# Function to check and compare points for potential solutions
def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check_modulo = gmpy2.f_mod(P.x, DP_rarity)
    
    if check_modulo != 0:
        return False

    message = f"\r[+] [Pindex]: {mpz(Pindex)}"
    messages = []
    messages.append(message)
    output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output)
    sys.stdout.flush()

    A.append(mpz(P.x))
    Ak.append(mpz(Pindex))

    collision_index_A = find_collision(Ak)
    if collision_index_A is not None:
        return comparator(A, Ak, B, Bk, collision_index_A)

    collision_index_B = find_collision(Bk)
    if collision_index_B is not None:
        return comparator(A, Ak, B, Bk, collision_index_B)

    return False

# Cycle detection function for Ak
def find_collision(Ak):
    seen = set()
    for i, item in enumerate(Ak):
        if item in seen:
            return mpz(i)  # Collision detected, return as mpz
        seen.add(item)
    return None  # No collision detected

# Cycle detection function for Bk
def find_collision(Bk):
    seen = set()
    for i, item in enumerate(Bk):
        if item in seen:
            return mpz(i)  # Collision detected, return as mpz
        seen.add(item)
    return None  # No collision detected

# Function to compare two sets of points and find a common point
def comparator(A, Ak, B, Bk, collision_index):
    global STOP_EVENT
    result = set(A).intersection(set(B))
    if result:
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        difference = Ak[sol_kt] - Bk[sol_kw]
        HEX = "%064x" % difference
        wifc = ice.btc_pvk_to_wif("%064x" % mpz(difference))
        dec = int(ice.btc_wif_to_pvk_hex(wifc), 16)
        wifu = ice.btc_pvk_to_wif(HEX, False)  # Uncompressed
        uaddr = ice.privatekey_to_address(0, False, dec)  # Uncompressed
        caddr = ice.privatekey_to_address(0, True, dec)  # Compressed
        HASH160 = ice.privatekey_to_h160(0, True, dec).hex()
        t = time.ctime()
        total_time = time.time() - starttime
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.2f} sec \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {wifc} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nPUZZLE SOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write('\nPrivate Key (dec): ' + str(dec))
            file.write('\nPrivate Key (hex): ' + HEX)
            file.write('\nPrivate Key Compressed: ' + wifc)
            file.write('\nPrivate Key Uncompressed: ' + wifu)
            file.write('\nPublic Address Compressed: ' + caddr)
            file.write('\nPublic Address Uncompressed: ' + uaddr)
            file.write('\nPublic Key Hash Compressed (Hash 160): ' + HASH160)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------\n"
            )

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

# Memoization for point multiplication
ECMULTIPLY_MEMO = {}

# Function to multiply a point by a scalar
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))

# Recursive function to multiply a point by a scalar
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))

# Generate a list of powers of two for faster access
@lru_cache(maxsize=None)
def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Worker function for point search
def search_worker(Nt, Nw, puzzle, tortoise_power, starttime, lower_range_limit, upper_range_limit):
    global STOP_EVENT

    random_state_t = gmpy2.random_state(hash(gmpy2.random_state()))
    random_state_w = gmpy2.random_state(hash(gmpy2.random_state()))

    t = [mpz(lower_range_limit + gmpy2.mpz_random(random_state_t, upper_range_limit - lower_range_limit)) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
    
    w = [gmpy2.mpz_random(random_state_w, upper_range_limit - lower_range_limit) for _ in range(Nt)]
    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()
                raise SystemExit
            t[k] += dt[k]
            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()
                raise SystemExit
            w[k] += dw[k]
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break


# Main script
if __name__ == "__main__":
    os.system("clear")
    t = time.ctime()
    sys.stdout.write("\033[01;33m")
    sys.stdout.write(f"[+] {t}" + "\n")
    sys.stdout.write(f"[+] Cycle detected, applying Floyd's cycle-finding algorithm..." + "\n")
    sys.stdout.flush()
    # Configuration for the puzzle
    puzzle = 50
    compressed_public_key = "03f46f41027bbf44fafd6b059091b900dad41e6845b2241dc3254c7cdd3c5a16c6"  # Puzzle 50
    lower_range_limit = 2 ** (puzzle - 1)
    upper_range_limit = (2 ** puzzle) - 1
    tortoise_power = puzzle // 8
    Nt = Nw = (2 ** tortoise_power // puzzle) * puzzle + 8
    DP_rarity = 8 * puzzle
    hop_modulo = (puzzle // 2) + 8

    # Precompute powers of two for faster access
    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}")
    print("[+] [Xcoordinate]: %064x" % X)
    print("[+] [Ycoordinate]: %064x" % Y)

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

    Hops = 0

    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,
                tortoise_power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join() 

[alek76]

Hello everyone, and especially those who still remember me)
I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs.
OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon...

Code:

C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 1 -bits 66 -r 5 -level 1 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL Used functions level 1             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]

Difficulty: 1461501637330902918203684832716283019655932542976
Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed]
Start Fri Sep 22 23:00:18 2023
Base Key: Randomly changed every 5 Mkeys
Number of CPU thread: 1

Bit 60 Base Key thId 0: 9F79EEEC674E61F < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 29D1A41009D12513A
[0.89 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.35][Prob 0.0%][50% in 3.60851e+34y][Found 0]
Bit 64 Base Key thId 0: E3643540371FB847 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 64 Base Key thId 0: 80A2CD8B9A3C23BC < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 3A53B397C7C3998F9
[0.85 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.51][Prob 0.0%][50% in 3.768e+34y][Found 0]
Bit 66 CPU Base Key thId 0: 33A47F5D6B844E5CE
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.14][Prob 0.0%][50% in 3.90297e+34y][Found 0]
Bit 66 CPU Base Key thId 0: 23B25CA07BAC32C6F
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.58][Prob 0.0%][50% in 3.9043e+34y][Found 0]
Bit 65 Base Key thId 0: 12FF6314297C60ECB < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 25B540E692C67500B
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.92][Prob 0.0%][50% in 3.90599e+34y][Found 0]
Bit 65 Base Key thId 0: 14F6F111D9ADFE665 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 28F5EB0F8DBAF6E80
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.19][Prob 0.0%][50% in 3.90512e+34y][Found 0]
Bit 66 CPU Base Key thId 0: 33755278B8367C2C3
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.42][Prob 0.0%][50% in 3.89525e+34y][Found 0]
Bit 64 Base Key thId 0: C63FFCFE4B85011C < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 36CA7D64880F6EC8E
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.59][Prob 0.0%][50% in 3.89824e+34y][Found 0]
Bit 65 Base Key thId 0: 1602E2E612E2D1D5D < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 64 Base Key thId 0: 9CE5D3E01377163B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 22729A06418E0AA07
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.77][Prob 0.0%][50% in 3.90262e+34y][Found 0]
Bit 65 Base Key thId 0: 1E4BA74256A46FFF2 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 65 Base Key thId 0: 19A395587DDFF6849 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 201909FF60F39CB91
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.89][Prob 0.0%][50% in 3.90116e+34y][Found 0]

Code:

C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 2 -bits 66 -r 5 -level 4 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL RAND_screen() OK                   ]
[===========================================================]
[                OpenSSL Used functions level 4             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]


[i] RAND_add() Seed with CPU performance counter: 413322837980
Difficulty: 1461501637330902918203684832716283019655932542976
Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed]
Start Fri Sep 22 23:25:51 2023
Base Key: Randomly changed every 5 Mkeys
Number of CPU thread: 2

[i] RAND_add() Seed with CPU performance counter: 413323029166

Bit 64 Base Key thId 1: C3B95A81B85BFE25 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 1: 20D9401B0A4FFDD06

[i] RAND_add() Seed with CPU performance counter: 413323029845

Bit 64 Base Key thId 0: A5BB18323A7CB6AB < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 295244E678E41E12E
[1.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.85][Prob 0.0%][50% in 1.76408e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413333913173

Bit 66 CPU Base Key thId 0: 29EF09292123E8168

[i] RAND_add() Seed with CPU performance counter: 413333913233

Bit 65 Base Key thId 1: 1FC1E88D8E95BC854 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 61 Base Key thId 1: 11B4BEA1EE95FF48 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 1: 27D8A8F52B15BE829
[1.72 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.76][Prob 0.0%][50% in 1.86995e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413343522509

Bit 66 CPU Base Key thId 0: 396121E3EFFA2A03C

[i] RAND_add() Seed with CPU performance counter: 413343523260

Bit 66 CPU Base Key thId 1: 2D60B4F910B675F54
[1.68 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.31][Prob 0.0%][50% in 1.90682e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413353124168

[i] RAND_add() Seed with CPU performance counter: 413353124942

Bit 64 Base Key thId 1: B461B1FC1240503B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 1: 2C1BC11A5C0C595BA

Bit 66 CPU Base Key thId 0: 32DFF58084D0F0B48
[1.67 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.72][Prob 0.0%][50% in 1.92559e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413362823436

Bit 66 CPU Base Key thId 1: 2664445EC6A550E07

[i] RAND_add() Seed with CPU performance counter: 413362823661

Bit 66 CPU Base Key thId 0: 27E59959139581FB5
[1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.03][Prob 0.0%][50% in 1.98491e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413372570037

[i] RAND_add() Seed with CPU performance counter: 413372575962

Bit 66 CPU Base Key thId 1: 2DA47EF2D2A90A017

Bit 66 CPU Base Key thId 0: 33A1C28B16D799A69
[1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.29][Prob 0.0%][50% in 1.98281e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413382240693

[i] RAND_add() Seed with CPU performance counter: 413382241494

Bit 61 Base Key thId 1: 147BF7CC10BC669B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 1: 2BC45552F10B6FAF2

Bit 66 CPU Base Key thId 0: 3BF647F72F5534012
[1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.40][Prob 0.0%][50% in 1.98292e+34y][Found 0]

Code:

C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 2 -bits 28 -r 5 -level 1 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL Used functions level 1             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]

Difficulty: 1461501637330902918203684832716283019655932542976
Search: 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY [Compressed]
Start Fri Sep 22 23:32:33 2023
Base Key: Randomly changed every 5 Mkeys
Number of CPU thread: 2

Bit 28 CPU Base Key thId 0: F3DDC63

Bit 28 CPU Base Key thId 1: CFD7541
[1.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.86][Prob 0.0%][50% in 1.76379e+34y][Found 0]
Bit 28 CPU Base Key thId 1: D299DE3

Bit 28 CPU Base Key thId 0: BAC1B81
[1.73 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.78][Prob 0.0%][50% in 1.85735e+34y][Found 0]
Bit 28 CPU Base Key thId 1: CC24254

Bit 26 Base Key thId 0: 2165974 < 8000000 or > FFFFFFF Rekey true

Bit 28 CPU Base Key thId 0: CC18276
[1.69 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.33][Prob 0.0%][50% in 1.8972e+34y][Found 0]
Bit 27 Base Key thId 1: 4B1D339 < 8000000 or > FFFFFFF Rekey true

Bit 28 CPU Base Key thId 1: D517B81

Bit 26 Base Key thId 0: 24181FC < 8000000 or > FFFFFFF Rekey true

Bit 26 Base Key thId 0: 2639DB4 < 8000000 or > FFFFFFF Rekey true

Bit 27 Base Key thId 0: 5992E85 < 8000000 or > FFFFFFF Rekey true

Bit 26 Base Key thId 0: 3AE84E6 < 8000000 or > FFFFFFF Rekey true

Bit 28 CPU Base Key thId 0: DF7A263
[1.68 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.73][Prob 0.0%][50% in 1.91598e+34y][Found 0]
Bit 27 Base Key thId 1: 596F852 < 8000000 or > FFFFFFF Rekey true

Bit 27 Base Key thId 1: 5005795 < 8000000 or > FFFFFFF Rekey true

Bit 28 CPU Base Key thId 1: C626164

Bit 28 CPU Base Key thId 0: D72E1A1
[1.63 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.90][Prob 0.0%][50% in 1.97098e+34y][Found 0]

  Addr :12jbtzBb54r97TCwW3G1gCFoumpckRAPdY
  Check:12jbtzBb54r97TCwW3G1gCFoumpckRAPdY

!!! Result.txt Found key: D916CE8
!!! Result.txt Found key: D916CE8
!!! Result.txt Found key: D916CE8
!!! Result.txt Found key: D916CE8
!!! Result.txt Found key: D916CE8

Has anyone used OpenSSL to generate keys?
Probably not..

[albert0bsd]

Has anyone used OpenSSL to generate keys?
Probably not..

Please don't belive that you are the only one who think in that... 

Yes, I checked some SSL libs on linux. Most of them works ok, The useful thing is when you tested some buggy version of it. but you need to check the source code to see where the bug is and use it to generate "weak" keys.

[alek76]

Please don't belive that you are the only one who think in that...  

Yes, I checked some SSL libs on linux. Most of them works ok, The useful thing is when you tested some buggy version of it. but you need to check the source code to see where the bug is and use it to generate "weak" keys.

Yes, that's absolutely true. Here I spent a week digging through old versions of OpenSSL from their official source. Weak keys are possible if assembled incorrectly. For example, like in older versions of Bitcoin core bitcoin-0.2.0, where RandAddSeedPerfmon() for Linux does not work, not used function RAND_add().
Downloaded DLLs can be checked by saving them keys to file and checking for duplicates. But this is unlikely all, a very large range. In general, a good Random will not hurt to solve bit 66, since the versions and key generation programs for this puzzle are not known. Perhaps the purpose of its creation will help, but perhaps its purpose is also to test the strength of OpenSSL libraries. Although there are so many external events that it is not possible to re-generate duplicate keys, unless there are broken versions - removing some functions to generate a weak key.
Perhaps someone decided to check old versions and created this puzzle.

[tetaeridanus]

is this puzzle still unsolved to date?

[digaran]

is this puzzle still unsolved to date?

It's not one puzzle, there are 160 in total, some of them are already solved, #66 is not yet solved. #130 also not solved but these 2 are next in line.


Guys anyone here knows python? Of course you do, I'm stuck for days to make this happening, at first I wanted to have such function inside another script but I failed, so I thought of something else, the following script opens 2 text files, reads the keys in both and subtracts them from each other, that's the logic but whatever I did I couldn't get it to take public keys from each line of the files and do the subtraction with them all, it just reads the last line and returns only 1 result obviously, if you could provide a fix, it'd be great.

Code:

# secp256k1 curve parameters
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
a = 0
b = 7
Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

# Point addition and subtraction functions
def point_add(P, Q):
    if P == Q:
        return point_double(P)
    if P is None:
        return Q
    if Q is None:
        return P
    lam = ((Q[1] - P[1]) * pow(Q[0] - P[0], p-2, p)) % p
    x = (lam * lam - P[0] - Q[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def point_sub(P, Q):
    if Q is None:
        return P
    # instead of using p - Q[1], use -Q[1] % p to correctly compute y coordinate
    Q_neg = (Q[0], (-Q[1]) % p)
    return point_add(P, Q_neg)

# Point doubling function
def point_double(P):
    if P is None:
        return None
    lam = ((3 * P[0] * P[0] + a) * pow(2 * P[1], p-2, p)) % p
    x = (lam * lam - 2 * P[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def is_valid_point(point):
    # Check that the point is not the point at infinity
    if point is None:
        return False
    
    x, y = point
    # Check that the coordinates are within the allowed range
    if x < 0 or x >= p or y < 0 or y >= p:
        return False
    
    # Check that the point lies on the curve
    return (y*y - x*x*x - a*x - b) % p == 0

def decompress_point(compressed_key):
    if compressed_key.startswith(b'\x02') or compressed_key.startswith(b'\x03'):
        x = int.from_bytes(compressed_key[1:], byteorder='big')
        y_sq = (x * x * x + a*x + b) % p
        y = pow(y_sq, (p+1)//4, p)
        if (y*y) % p == y_sq:
            return (x, y)
        else:
            return None
    else:
        return None

def compress_point(point):
    x, y = point
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    return prefix + x.to_bytes(32, byteorder='big')

def point_subtraction(compressed_keys):
    P = None
    for compressed_key in compressed_keys:
        Q = decompress_point(compressed_key)
        
        # Check that the point is valid on the curve
        if not is_valid_point(Q):
            return None
        
        if P is None:
            P = Q
        else:
            P = point_sub(P, Q)
        
        # Check that the resulting point is not the point at infinity
        if P is None:
            return None
    
    if is_valid_point(P):
        return compress_point(P)
    else:
        return None

compressed_keys = []
file1 = open('file1.txt', 'r')
for line in file1:
    compressed_keys.append(bytes.fromhex(line.strip()))
file1.close()

file2 = open('file2.txt', 'r')
for line in file2:
    compressed_keys.append(bytes.fromhex(line.strip()))
file2.close()

result = point_subtraction(compressed_keys)

if result:
    file3 = open('result.txt', 'a')
    file3.write(result.hex() + "\n")
    file3.close()
else:
    print("The subtraction result is not a valid point on the curve.")

I know the problem is in line.strip section, just don't know how, btw I asked AI, it started by implementing sha256 for no reason, ended up with giving me some test cases from bitcoin wiki. Go figure!


Note, it's for academic purposes only ( whatever that means anyway ).😉

[7isce]

You could just use it as

Code:

file1 = open('file1.txt', 'r')
for line in file1.read().splitlines():
    compressed_keys.append(bytes.fromhex(line))
file1.close()

file2 = open('file2.txt', 'r')
for line in file2.read().splitlines():
    compressed_keys.append(bytes.fromhex(line))
file2.close()

Good Luck with your studies  

[digaran]

Didn't work, still outputs a single result which is the result of last public keys in my files subtracted, this new method I'm working on is not yet tested, so I can't share it before testing it myself.

I managed to make up a scalar mod n version of my script, but as a py noob, I can't learn so many things in a short period of time. Thanks for the effort though.
Maybe I'm  unsuccessful because I'm using mobile instead of laptop? Lol I should find some place else for my coding guidance.

My new script can solve any key in scalar mode of course.

[citb0in]

I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs.
OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon...

Sounds interesting as long as the source code is available so one can compile the program. Is it available for download ?

[alek76]

I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs.
OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon...

Sounds interesting as long as the source code is available so one can compile the program. Is it available for download ?

Today I checked the GPU code again, since I removed the unnecessary calculations of Ripemd160 (left 1 out of 6) and it works correctly. I needed to make sure again that everything was correct. In this code I also used functions from the Bitcoin client - to add a seed, the Rand_add() function. I'll post it on Github in the near future, because... With my computing resources it will not be possible to find a solution to bit 66. If they find it using my fork, then send me a tips . Coming soon.
I managed to get this speed on Tesla T4:

Code:

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
OpenSSL 3.0.2 15 Mar 2022 (Library: OpenSSL 3.0.2 15 Mar 2022)
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL Used functions level 4             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
                                                             

[i] RAND_add() Seed with CPU performance counter: 1695456415355946 
Difficulty: 1461501637330902918203684832716283019655932542976
Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed]
Start Sat Sep 23 08:06:55 2023
Base Key: Randomly changed every 100000 Mkeys
Number of CPU thread: 0
GPU: GPU #0 Tesla T4 (40x64 cores) Grid(320x128)

[i] RAND_add() Seed with CPU performance counter: 1695456415480157 
Bit 66 GPU Base Key 0: 2DAFFE6ACD76ABC1D
Bit 66 GPU Base Key 1: 27AD93FD5D885B767
Bit 66 GPU Base Key 2: 2D67AE2D1731671C5
Bit 66 GPU Base Key 3: 3C77CC7B5C7587A86
Bit 66 GPU Base Key 4: 277448DA9C423D147
Bit 66 GPU Base Key 5: 2F7EDC7B5C2B09F0F
Bit 66 GPU Base Key 6: 3DABCD2B602D43EA8
Bit 66 GPU Base Key 7: 238936C644C88AB7E
Bit 66 GPU Base Key 8: 3A97B3F0171947B59
Bit 66 GPU Base Key 9: 31B6CDD325D6B3FB7
Bit 66 GPU Base Key 40951: 3211CC54F75B5CD00
Bit 66 GPU Base Key 40952: 2327D47C30738E157
Bit 66 GPU Base Key 40953: 2A66575CC34FA37C6
Bit 66 GPU Base Key 40954: 2981DD1BA18306814
Bit 66 GPU Base Key 40955: 3775C5C27150FEA12
Bit 66 GPU Base Key 40956: 37A37E2863197B3DB
Bit 66 GPU Base Key 40957: 3D78C9919D6B6A072
Bit 66 GPU Base Key 40958: 22100282EE8370965
Bit 66 GPU Base Key 40959: 37E28F54F8EC9B7D2

[i] RAND_add() Seed with CPU performance counter: 1695456416086342 
Bit 66 GPU Base Key 0: 33D16FF3A68C0BA73
Bit 66 GPU Base Key 1: 359F2BA0E89868D5E
Bit 66 GPU Base Key 2: 3DDDCE27056C63AD9
Bit 66 GPU Base Key 3: 2EFF53109E165A31F
Bit 66 GPU Base Key 4: 236DC50A204B42078
Bit 66 GPU Base Key 5: 2F128D7562A4DDC32
Bit 66 GPU Base Key 6: 2743F1524E422DF51
Bit 66 GPU Base Key 7: 284ECC8C4DC852018
Bit 66 GPU Base Key 8: 3932B5EC487EACE6A
Bit 66 GPU Base Key 9: 398E4AEE55E284239
Bit 66 GPU Base Key 40951: 3225C10410AF00667
Bit 66 GPU Base Key 40952: 229E0588B78FCDF88
Bit 66 GPU Base Key 40953: 25DAC65EBE4EF6B6B
Bit 66 GPU Base Key 40954: 2C5621F3B0D87CFB8
Bit 66 GPU Base Key 40955: 229EC31EBF4F800D2
Bit 66 GPU Base Key 40956: 31F29B5822AA4E982
Bit 66 GPU Base Key 40957: 27C891A611B7D7A20
Bit 66 GPU Base Key 40958: 2F1351CB9E5A7812F
Bit 66 GPU Base Key 40959: 22D025D76B453D748
[615.93 Mkey/s][GPU 615.93 Mkey/s][Total 2^36.06][Prob 0.0%][50% in 5.21538e+31y][Found 0]

Coming soon... Already available https://github.com/alek76-2/VanitySearch

[digaran]

Coming soon.

Once upon a time,  there existed a WanderingPhilospher who also was a brute force developer, he used to be my mentor, he taught a lot of useful stuff to me. Will you be my new mentor? Lol
Do you have anything useful and fast that could do public key calculations to solve for private key? I have some ideas which I need to test extensively to make sure it could be used to solve DLP, God willing after a successful test run, I might bother you to develop something new!

[alek76]

Coming soon.

Once upon a time,  there existed a WanderingPhilospher who also was a brute force developer, he used to be my mentor, he taught a lot of useful stuff to me. Will you be my new mentor? Lol
Do you have anything useful and fast that could do public key calculations to solve for private key? I have some ideas which I need to test extensively to make sure it could be used to solve DLP, God willing after a successful test run, I might bother you to develop something new!

Not funny at all! I already have a version with random divide of the public key.
I talked to WanderingPhilospher a couple of years ago, I remember well when I remade the starting keys for Kangaroo.
And probably everyone forgot that I was the first to post the GPU code for Kangaroo and this was before the release date of Kangaroo from Jean-Luc Pons.
here is the link: https://bitcointalk.org/index.php?topic=5218972.msg54089243#msg54089243
At that time, I pushed this topic very hard, and soon a version from Jean-Luc Pons appeared. Thank him very much.
As promised, I published the fork code on Github https://github.com/alek76-2/VanitySearch
Enjoy it, and if you find solution 66 with this version, don’t forget about me  

[mcdouglasx]

is this puzzle still unsolved to date?

It's not one puzzle, there are 160 in total, some of them are already solved, #66 is not yet solved. #130 also not solved but these 2 are next in line.


Guys anyone here knows python? Of course you do, I'm stuck for days to make this happening, at first I wanted to have such function inside another script but I failed, so I thought of something else, the following script opens 2 text files, reads the keys in both and subtracts them from each other, that's the logic but whatever I did I couldn't get it to take public keys from each line of the files and do the subtraction with them all, it just reads the last line and returns only 1 result obviously, if you could provide a fix, it'd be great.

Code:

# secp256k1 curve parameters
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
a = 0
b = 7
Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

# Point addition and subtraction functions
def point_add(P, Q):
    if P == Q:
        return point_double(P)
    if P is None:
        return Q
    if Q is None:
        return P
    lam = ((Q[1] - P[1]) * pow(Q[0] - P[0], p-2, p)) % p
    x = (lam * lam - P[0] - Q[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def point_sub(P, Q):
    if Q is None:
        return P
    # instead of using p - Q[1], use -Q[1] % p to correctly compute y coordinate
    Q_neg = (Q[0], (-Q[1]) % p)
    return point_add(P, Q_neg)

# Point doubling function
def point_double(P):
    if P is None:
        return None
    lam = ((3 * P[0] * P[0] + a) * pow(2 * P[1], p-2, p)) % p
    x = (lam * lam - 2 * P[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def is_valid_point(point):
    # Check that the point is not the point at infinity
    if point is None:
        return False
    
    x, y = point
    # Check that the coordinates are within the allowed range
    if x < 0 or x >= p or y < 0 or y >= p:
        return False
    
    # Check that the point lies on the curve
    return (y*y - x*x*x - a*x - b) % p == 0

def decompress_point(compressed_key):
    if compressed_key.startswith(b'\x02') or compressed_key.startswith(b'\x03'):
        x = int.from_bytes(compressed_key[1:], byteorder='big')
        y_sq = (x * x * x + a*x + b) % p
        y = pow(y_sq, (p+1)//4, p)
        if (y*y) % p == y_sq:
            return (x, y)
        else:
            return None
    else:
        return None

def compress_point(point):
    x, y = point
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    return prefix + x.to_bytes(32, byteorder='big')

def point_subtraction(compressed_keys):
    P = None
    for compressed_key in compressed_keys:
        Q = decompress_point(compressed_key)
        
        # Check that the point is valid on the curve
        if not is_valid_point(Q):
            return None
        
        if P is None:
            P = Q
        else:
            P = point_sub(P, Q)
        
        # Check that the resulting point is not the point at infinity
        if P is None:
            return None
    
    if is_valid_point(P):
        return compress_point(P)
    else:
        return None

compressed_keys = []
file1 = open('file1.txt', 'r')
for line in file1:
    compressed_keys.append(bytes.fromhex(line.strip()))
file1.close()

file2 = open('file2.txt', 'r')
for line in file2:
    compressed_keys.append(bytes.fromhex(line.strip()))
file2.close()

result = point_subtraction(compressed_keys)

if result:
    file3 = open('result.txt', 'a')
    file3.write(result.hex() + "\n")
    file3.close()
else:
    print("The subtraction result is not a valid point on the curve.")

I know the problem is in line.strip section, just don't know how, btw I asked AI, it started by implementing sha256 for no reason, ended up with giving me some test cases from bitcoin wiki. Go figure!


Note, it's for academic purposes only ( whatever that means anyway ).😉

This code reads line by line from a file.

Code:

file= open("data-base_line_by_line.txt", "r")
lines = file.readlines()
for index, line in enumerate(lines):
    
    target = str(line.strip())
    print(target)

edit:
if you just want to subtract (lines in file1) - (lines in file2) use this:

Code:

import itertools
import secp256k1 as ice



with open('file1.txt', 'r') as f1, open('file2.txt', 'r') as f2:
    

    for line1, line2 in zip(f1, f2):
        
        x=  ice.pub2upub(str(line1.strip()))

        x2= ice.pub2upub(str(line2.strip()))

        res = ice.point_subtraction(x, x2).hex()
        
        result= ice.to_cpub(res)

        file3 = open('result.txt', 'a')
        file3.write(result + "\n")
        file3.close()

   

[Kostelooscoin]

this python script generates about 144M private keys with the X and Y keys, which takes a long time to generate, so I'd like to know if it would be possible to speed up the process by keeping the calculation method used in the script, even if it's just a matter of generating the private keys while keeping the calculation method?

addressgeneration.py

Code:

from ecdsa import SigningKey, SECP256k1
import sha3
from binascii import unhexlify
import hashlib
from base58 import b58encode
import bech32
from cashaddress import convert
import datetime

def PrivateKeyComputation(p1: int, p2: int, p3: int, base: int, n: int):
    order = (2 ** 6) * 3 * 149 * 631 * p1 * p2 * p3
    prod = p1 * p2 * p3
    g = pow(base, prod, order + 1)
    privateSet = [None] * n

    for i in range(n):
        if i == 0:
            privateSet[0] = hex(g)
        else:
            k = (g * int(privateSet[i - 1], 16)) % (order + 1)
            privateSet[i] = hex(k)

    return privateSet

def CosetPrivateKeyComputation(p1: int, p2: int, p3: int, base: int, n: int):
    print("Coset PrivateKey Computation started at", datetime.datetime.now())
    prod = p1 * p2 * p3
    h = (2 ** 6) * 3 * 149 * 631
    order = h * prod
    g = pow(base, prod, order + 1)
    privateSet = [None] * n * 8

    for i in range(n):
        if i == 0:
            privateSet[0] = hex(g)
        else:
            k = (g * int(privateSet[i - 1], 16)) % (order + 1)
            privateSet[i] = hex(k)

    pows = [h, h*p1, h*p2, h*p3, h*p1*p2, h*p1*p3, h*p2*p3]

    for j in range(len(pows)):
        g = pow(base, pows[j], order + 1)
        for i in range(n):
            value = (g * int(privateSet[i], 16)) % (order + 1)
            privateSet[(j+1)*h+i] = hex(value)
    print("Coset PrivateKey Computation finished at", datetime.datetime.now())
    return privateSet

def CosetKeysFile(n: int, privateSet):
    print("Writing on txt file started at", datetime.datetime.now())
    f = open("secp256k1_keys.txt", "r+")
    f.seek(0)
    f.write('\t\tPrivateKey  \t\t\t\t\t\t\t\t\t\t  PublicKey-x \t\t\t\t\t\t\t\t\t\t   PublicKey-y  \n')

    for i in range(8*n):
        k = int(privateSet[i], 16).to_bytes(32, "big")
        k = SigningKey.from_string(k, curve=SECP256k1)
        K = k.get_verifying_key().to_string()

        f.write(str(i) + ')\t' + privateSet[i] + '\t' + K.hex()[0:64] + '\t' + K.hex()[64:128] + '\n')

    f.truncate()
    f.close()
    print("Writing on txt file finished at", datetime.datetime.now())

def UncompressedPublicKeyComputation(x, y):
    publicKey = '04' + str(x) + str(y)
    return publicKey

def CompressedPublicKeyComputation(x, y):
    if int(y, 16) % 2 == 0:
        publicKey = '02' + str(x)
    else:
        publicKey = '03' + str(x)

    return publicKey

def checksum_computation(string: str) -> hex:
    cs = hashlib.sha256(hashlib.sha256(unhexlify(string)).digest()).hexdigest()
    checksum = cs[:8]
    return checksum

def BitcoinClassicAddressComputation(publicKey):
    public_key_bytes = unhexlify(publicKey)

    sha256 = hashlib.sha256()
    sha256.update(public_key_bytes)
    hash_temp = sha256.digest()

    ripemd160 = hashlib.new('Ripemd160')
    ripemd160.update(hash_temp)
    hash2_temp = ripemd160.hexdigest()

    hash3_temp = '00' + hash2_temp

    checksum = checksum_computation(hash3_temp)

    hash_final = hash3_temp + str(checksum)
    hash_final_bytes = unhexlify(hash_final)
    address = b58encode(hash_final_bytes).decode("utf-8")
    return address

KeysFileGeneration.py

Code:

import AddressGeneration

p1 = 107361793816595537
p2 = 174723607534414371449
p3 = 341948486974166000522343609283189
base = 7
h = (2 ** 6) * 3 * 149 * 631


privateSet = AddressGeneration.CosetPrivateKeyComputation(p1, p2, p3, base, h)
PublicSet = AddressGeneration.CosetKeysFile(h, privateSet)

[alek76]

this python script generates about 144M private keys with the X and Y keys, which takes a long time to generate, so I'd like to know if it would be possible to speed up the process by keeping the calculation method used in the script, even if it's just a matter of generating the private keys while keeping the calculation method?

144M private keys are a drop in the ocean of keys. What's the point of generating public keys from private keys (it takes a long time). You need to add and multiply and divide public keys (XY coordinates). The process can of course be speeded up if you use C++. Not a single Python script has yet found complex solutions to a puzzle.
You have some unique creative designs from Jean Luc Pons, this is the highest level of programming skill and experience. Everything else can only be modified, new algorithms and new functions can be added to the C++ code. Look in the wrong direction... It's better to find the correct divisor for the unknown private key. Correct - this means the remainder of the division is zero!!! This is a good task, then there will be a result.