Bitcoin puzzle transaction ~32 BTC prize to who solves it

[albert0bsd]

if you have a True randomness in your PC you will have possibility to have consciousness in your computer.

Not just me, every body with a moderm CPU and a good RNG algorithm in its OS (So every linux/windows)

Did you bothered in read what i quote from that page?

From: https://www.intel.com/content/www/us/en/developer/articles/guide/intel-digital-random-number-generator-drng-software-implementation-guide.html

The ES runs asynchronously on a self-timed circuit and uses thermal noise within the silicon to output a random stream of bits at the rate of 3 GHz

@nomachin WTF? You just ignore what i write and started to talking about something that is not related.

Artificial Intelligence, singularity, simulations? WTF?? What is the relationship between that and this TOPIC?

[1714974586]

1714974586

[1714974586]

1714974586

[1714974586]

1714974586

[1714974586]

1714974586

[digaran]

Guys/gals, don't waste your time with random search, random mode etc, there is no such a thing as "random" all events follow a pattern,  we as humans have to interfere and change these patterns, by following logic and the power of our minds.
Instead of "hoping" for a "lucky" hit in a random search, start working on ways to find a stride for public key brute force.
Example:
Target = 127654 (unknown) we only know it's between 100,000 and 200,000.
So we subtract it from 200,000 - 127654 = 72,346.  Now we are certain our result is 100% smaller than 100,000 (start range), but since we don't know how much smaller, we'd just subtract it from half of start range, 50,000 - 72,346 = 22,346. And now we are 100% certain the result is smaller than 50,000 but we don't know how much, again we subtract it from 1/4 of start range 25,000 - 22,346 = 2,654.

Now tell me what do you see?
127654
2654
127654 - 2654 = 125000
What you need to work on is figuring out a stride to add to 125,000 till we reach our target, whether we add 13 at each step, 14 or 15, what happens when we reach 127698? Can we save the keys between 127654 and 127700 so when we are adding stride and land on one of the saved keys, we know right away and easily solve the key or not?

These things should be your priority, enough of running this tool/script and that tool/script, come up with an algorithm which doesn't require "random" and "luck" but requires math equations and numbers.

[Ovixx]

Guys/gals, don't waste your time with random search, random mode etc, there is no such a thing as "random" all events follow a pattern,  we as humans have to interfere and change these patterns, by following logic and the power of our minds.
.................

I still believe that the random mode is more effective than the subtraction that you have been mentioning for a while and you are only looking for a solution where there is none, but I wish you success. Everyone applies their own way. Let's see who can do it first, shall we?
...by the way, you do some stupid calculations in which only you see something....Do you somehow see the Eiffel Tower on the left side?

[nomachine]

@nomachin WTF? You just ignore what i write and started to talking about something that is not related.

Artificial Intelligence, singularity, simulations? WTF?? What is the relationship between that and this TOPIC?

You keep insisting that the RNG must be safe and by some (security) rules.. .I assume written by the NSA itself?
You need slow and safe/secure (unpredictable) when you create and protect BTC,  not when you hack it.
The rule is that when you hacking there are no rules.

Is all this a robbery/steal/theft attempt?

It is definitely a hacker attempt/attack.  Tell the truth and . . .run  

[Baskentliia]

@nomachine - for another puzzle, do I need to change anything in the script other than keyrange and pubkey? Why am I asking you? Because, in order to test, I put the public key from #64 and a very small keyrange, between f7051f26b09112d4 and f7051f2ab09112d4 (17799667353283269332:17799667370463138516) and it is obvious that the search is done outside the keyrange, in decimal, from 10000000000000000000 to 29999999999999999999 or even greater.

Pindex is essentially an identifier for the points being processed and helps keep track of the progress of the search and identify points that could potentially solve the cryptographic puzzle. It's used to match points from different sets and determine if they share the same x-coordinate. Since these values are generated randomly, they may not always fall within the specified range, especially if the random number generation is not constrained.
The script employs a kangaroo twins hopping strategy to search for solutions. The hopping strategy involves adding a certain value to the x-coordinate of a point and then computing the next point in the sequence. Depending on the hopping value, it is possible for the point to move outside the defined range.

I am getting error like this:

C:\Users\abc\Desktop>py 4.py
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Using  8 CPU cores for parallel search]:

'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3

multiprocessing.pool.RemoteTraceback:
"""
Traceback (most recent call last):
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 125, in worker
    result = (True, func(*args, **kwds))
                    ^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 51, in starmapstar
    return list(itertools.starmap(args[0], args[1]))
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\abc\Desktop\4.py", line 219, in search_worker
    with open("/dev/urandom", "rb") as urandom_file:
         ^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'
"""

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "C:\Users\abc\Desktop\4.py", line 277, in <module>
    results = pool.starmap(
              ^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 375, in starmap
    return self._map_async(func, iterable, starmapstar, chunksize).get()
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 774, in get
    raise self._value
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'

C:\Users\abc\Desktop>



help me bro

Go again there and copy/paste script - it is updated several times. The new version has a Core list for each seed.

https://bitcointalk.org/index.php?topic=1306983.msg62978550#msg62978550

Use "cls" instead of  "clear" in Windows  

p.s.
If someone has time (i'm sold out right now) , it wouldn't be a bad idea to make the same program in C++ with the same seed capabilities and to work above Puzzle 125 . . . It would work incomparably faster.

I tried to run it using Python on my brother's Windows, but it didn't work. I request a new update for Windows because the program is quite nice.

[digaran]

I still believe that the random mode is more effective than the subtraction that you have been mentioning for a while and you are only looking for a solution where there is none

We keep looking until we find one, if there was an easy to spot solution then we wouldn't be here at all, and my solution is not based on subtraction, it also includes division, however I'm working on a new method to multiply and divide 2 points, I know something impossible, right? At least I'm delusional by relying on mathematics, whilst you and a few others are delusional relying on "random" search without even realizing the probabilities of successfully landing on a target in a big range like 130 is beyond your comprehension.  You insist on a "luck" which doesn't exist, if you input 1 address and generate a random key and land on that 1 address, it's not called luck, God wanted it.

by the way, you do some stupid calculations in which only you see something....Do you somehow see the Eiffel Tower on the left side?

Yet I haven't seen you slapping me with these stupid calculations, proving me wrong and embarrassing me for everyone to see. ( wait there is a unicorn asking for directions for Champs-Élysées, let me give him an equation to solve for the address.) 😉🤣

Please learn how to quote and trim the unnecessary previous quotes, @everyone. Thanks

[nomachine]

I'm delusional by relying on mathematics, whilst you and a few others are delusional relying on "random" search

It doesn't matter what method did you use if you succeed in your intention. And no matter how crazy the way may seem,
this isn't conceptually different from picking up someone's safe and finding its lock combination, then claiming the safe's contents for the sake of science.  

[Legends_Never_Die]

this isn't conceptually different from picking up someone's safe and finding its lock combination, then claiming the safe's contents for the sake of science.  

Except these safes are publicly reachable unlike private safes inside houses. Consider yourself a security team member working on security issues, your payment is in puzzle addresses, find a hole and grab your payment, if the designer was a professional programmer, he wouldn't have made this puzzle, he is a good scientist but not a good programmer, as early bitcoin clients were full of bugs/code related issues, but the concept was perfect and it is to this day.  Scientists act based on science, puzzle hunters act based on monetary incentive.

"They asked someone, imagine you are in the middle of the ocean and sharks are approaching, what will you do?"
"He said I will climb a tree"
-They said but there are no trees in the middle of the ocean-
"He said I know, but I don't have any other choice"
🤣

[nomachine]

Except these safes are publicly reachable unlike private safes inside houses.

ATMs are publicly reachable. Try to hack them.  I'm kidding...  
🤣
I understand the whole story.    

[Baskentliia]

Code:

import sys
import os
import time
import random
import hashlib
import gmpy2
from gmpy2 import mpz
from functools import lru_cache
import multiprocessing
from multiprocessing import Pool, cpu_count

os.system("cls")

# 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
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
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 = gmpy2.f_mod(P.x, DP_rarity)
    if check == 0:
        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))
        return comparator(A, Ak, B, Bk)
    else:
        return False

# Function to compare two sets of points and find a common point
def comparator(A, Ak, B, Bk):
    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
        t = time.ctime()
        pid = os.getpid()  # Get the process ID
        core_number = pid % cpu_count()  # Calculate the CPU core number
        total_time = time.time() - starttime
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.2f} sec, Core: {core_number+1:02} \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {HEX} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write("\nPrivate Key (decimal): " + str(difference))
            file.write("\nPrivate Key (hex): " + HEX)
            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)]

t = time.ctime()
sys.stdout.write("\033[01;33m")
sys.stdout.write(f"[+] [Kangaroo]: {t}" + "\n")
sys.stdout.flush()

# Configuration for the puzzle
puzzle = 70
compressed_public_key = "0290e6900a58d33393bc1097b5aed31f2e4e7cbd3e5466af958665bc0121248483"  # Puzzle 70
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
kangaroo_power = puzzle // 8
Nt = Nw = (2 ** kangaroo_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

# Worker function for point search
def search_worker(
    Nt, Nw, puzzle, kangaroo_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''  #back to no constant
    #constant_prefix = b'\xbc\x9b\x8cd\xfc\xa1?\xcf' #Puzzle 50 seed - 10-18s
    constant_prefix = b'\xbc\x9b\x8cd'
    prefix_length = len(constant_prefix)
    length = 8
    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(
            lower_range_limit
            + mpz(random.randint(0, 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 = [
        mpz(random.randint(0, 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()
                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

# Main script
if __name__ == "__main__":
    process_count = 2
    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,
                kangaroo_power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

Try this, it works for me on windows.

Thank you brother I tried this and it worked

[WanderingPhilospher]

Guys/gals, don't waste your time with random search, random mode etc, there is no such a thing as "random" all events follow a pattern,  we as humans have to interfere and change these patterns, by following logic and the power of our minds.
Instead of "hoping" for a "lucky" hit in a random search, start working on ways to find a stride for public key brute force.
Example:
Target = 127654 (unknown) we only know it's between 100,000 and 200,000.
So we subtract it from 200,000 - 127654 = 72,346.  Now we are certain our result is 100% smaller than 100,000 (start range), but since we don't know how much smaller, we'd just subtract it from half of start range, 50,000 - 72,346 = 22,346. And now we are 100% certain the result is smaller than 50,000 but we don't know how much, again we subtract it from 1/4 of start range 25,000 - 22,346 = 2,654.

Now tell me what do you see?
127654
2654
127654 - 2654 = 125000
What you need to work on is figuring out a stride to add to 125,000 till we reach our target, whether we add 13 at each step, 14 or 15, what happens when we reach 127698? Can we save the keys between 127654 and 127700 so when we are adding stride and land on one of the saved keys, we know right away and easily solve the key or not?

These things should be your priority, enough of running this tool/script and that tool/script, come up with an algorithm which doesn't require "random" and "luck" but requires math equations and numbers.

Sorry man, this either will not work because you went around the curve, or you will have trillions^trillions of strides to go through/take.

Your example:
Target = 127654
range = 100,000 - 200,000

Like you said, we do not know the target, only the range.
So let's say the target's key is 199,999
Watch the math:
200,000 - 199,999 = 1
1 - 50,000 = -49,999
-49,999 - 25,000 = -74,999

You have now went backwards around the curve. So now, you can't even start your program to start striding from 0 or 1.

But let's deal with your math above and talk about the strides.

It's ok when a range is only 200,000 but now imagine a much larger range, say 2^130. If you have a stride of 13, 14, 15, etc., it will take you more than a lifetime to still get through that range.

[nomachine]

Here is new script....
Bytea HASH160 Search.
Bitcoin addresses and hashes are typically represented as byte sequences. When you work with bytes, you can directly perform binary operations and comparisons, which is faster and more efficient than dealing with hexadecimal or string representations.
In this context, the script generates private keys as integers and converts them into bytes to derive Bitcoin addresses. It then calculates the Hash160 of these addresses and compares it to the target Hash160.
Script uses puzzle creator method - the b'\x00' * 32 line creates a 32-byte value composed entirely of zero bytes. This is just an initial placeholder value, and as the script progresses, it replaces parts of these zeros with the random bytes generated to create a valid private key for Bitcoin.
You can also play with patterns and random seed values at the same time.

Code:

import sys
import os
import time
import random
import binascii
import base58
import hashlib
import ecdsa
from multiprocessing import cpu_count
import threading

# Set the Hash 160 address you want to check for
target_hex = "20d45a6a762535700ce9e0b216e31994335db8a5"
add_set = bytes.fromhex(target_hex)

puzzle = 66
min_number = 2 ** (puzzle - 1)
max_number = (2 ** puzzle) - 1

# Clear the terminal screen
if os.name == 'nt':
    os.system('cls')
else:
    os.system('clear')

# Print information about the program
t = time.ctime()
sys.stdout.write("\033[01;33m")
sys.stdout.write("\033[?25l")
sys.stdout.write(f"[+] [Bytea HASH160 Search] {t}" + "\n")
sys.stdout.write(f"[+] [Puzzle]: {puzzle}" + "\n")
sys.stdout.write(f"[+] [Lower range limit]: {min_number}" + "\n")
sys.stdout.write(f"[+] [Upper range limit]: {max_number}" + "\n")
sys.stdout.flush()

# Define the check_private_key function
def check_private_key(add_set):
    while True:
        constant_prefix = b''  #Can be b'\xbc\x9b' or any random_bytes
        prefix_length = len(constant_prefix)
        length = 8
        ending_length = length - prefix_length
        ending_bytes = os.urandom(ending_length)
        random_bytes = constant_prefix + ending_bytes
        random.seed(random_bytes)
        dec = random.randint(min_number, max_number)
        dec_bytes = dec.to_bytes((dec.bit_length() + 7) // 8, 'big')
        private_key_bytes = b'\x00' * 32
        private_key_bytes = private_key_bytes[:-len(dec_bytes)] + dec_bytes
        signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
        compressed_public_key = signing_key.get_verifying_key().to_string("compressed")
        sha256_hash = hashlib.sha256(compressed_public_key).digest()
        HASH160 = hashlib.new('ripemd160', sha256_hash).digest()
        extended_private_key = b'\x80' + private_key_bytes + b'\x01'
        extended_ripe160_hash = b'\x00' + HASH160
        checksum = hashlib.sha256(hashlib.sha256(extended_private_key).digest()).digest()[:4]
        checksum_ripe160 = hashlib.sha256(hashlib.sha256(extended_ripe160_hash).digest()).digest()[:4]
        private_key_with_checksum = extended_private_key + checksum
        HASH160_wif = base58.b58encode(private_key_with_checksum).decode()
        address_bytes = extended_ripe160_hash + checksum_ripe160
        bitcoin_address = base58.b58encode(address_bytes).decode()
        message = "\r[+] Public Key Hash (Hash 160): {}             ".format(HASH160.hex())
        messages = []
        messages.append(message)
        output = "\033[01;33m" + ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        if bitcoin_address.startswith("13zb1h"):
            sys.stdout.write(f"\n[+]\033[32m Pattern Found: {bitcoin_address}, {dec}, {random_bytes}              \033[0m")
            sys.stdout.write(f"\n[+] continue...\n")
        if HASH160 == add_set:
            dec_to_hex = hex(dec).split('x')[-1]
            t = time.ctime()
            sys.stdout.write(f"\033[0m\n\n")
            sys.stdout.write(f"[+] SOLVED:    |\033[32m{t}                                                                 \033[0m\n")
            sys.stdout.write(f"[+] Key Found: |\033[32m {dec_to_hex}                                               \033[0m\n"
                                        f"[+] WIF:       |\033[32m {HASH160_wif}                                                 \033[0m\n"
                                        f"[+] Address:   |\033[32m {bitcoin_address}                                          \033[0m\n"
                                        f"[+] Seed:      |\033[32m {random_bytes}                                               \033[0m\n\n")
            sys.stdout.flush()
            with open("KEYFOUNDKEYFOUND.txt", "a") as f:
                f.write("SOLVED: " + str(t) + '\n' + "HEX: " + str(dec_to_hex) + '\n' + "Address: " + str(bitcoin_address) + '\n' + "Private Key:  " + str(HASH160_wif)+ '\n' + "Random Seed:  " + str(random_bytes) + '\n\n')
                f.flush()
                f.close()
            sys.stdout.write("\033[?25h")
            sys.stdout.flush()
            return

# Create multiple threads for generating addresses
num_threads = cpu_count()
threads = []

for _ in range(num_threads):
    thread = threading.Thread(target=check_private_key, args=(add_set,))
    thread.start()
    threads.append(thread)

# Wait for all threads to finish
for thread in threads:
    thread.join()

[digaran]

Like you said, we do not know the target, only the range.
So let's say the target's key is 199,999

Alrighty then, to be exact, when it comes to slapping me suddenly the secure random generator gives us 199,999? And when we are working with 6 digits then as an example use 14, 15 etc, suddenly we go high as 2^130 and compare the numbers?
So why not scaling up all the values and use actual 2^130 range/keys? Though you forgot that I was asking if the stride idea could be tweaked to find a perfect stride or not.

Even if the key is e.g, 189776, we could still divide the end range and subtract from our target by different subranges, like 200,000 - 189776 = 10224, we could then try subtracting the result from endrange/4, er/6, er/8 etc.
Nvm that, I don't know anything about math, I'm not even working actively on 130, my target is much bigger.

Btw, Legends_Never_Die is my alter ego account, time for a paint job on trust wall.😉

[nomachine]

the secure random generator gives us 199,999

Try non-secure random generator

Code:

import random
puzzle = 18
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
seed = b'\x97h6\xd9\x7f\xcbh\xc4'
random.seed(seed)
dec = random.randint(lower_range_limit, upper_range_limit)
print(f"{dec}, {seed}")

 

[WanderingPhilospher]

Like you said, we do not know the target, only the range.
So let's say the target's key is 199,999

Alrighty then, to be exact, when it comes to slapping me suddenly the secure random generator gives us 199,999? And when we are working with 6 digits then as an example use 14, 15 etc, suddenly we go high as 2^130 and compare the numbers?
So why not scaling up all the values and use actual 2^130 range/keys? Though you forgot that I was asking if the stride idea could be tweaked to find a perfect stride or not.

Even if the key is e.g, 189776, we could still divide the end range and subtract from our target by different subranges, like 200,000 - 189776 = 10224, we could then try subtracting the result from endrange/4, er/6, er/8 etc.
Nvm that, I don't know anything about math, I'm not even working actively on 130, my target is much bigger.

Btw, Legends_Never_Die is my alter ego account, time for a paint job on trust wall.😉

I know you are used to spitting out random things and some are like ooooohhhhh ahhhhhhhhh, but you seldom listen lol.

You could be working in a 50 bit range or a 256 bit range; and you can subtract, divide, multiply, etc. whatever you want to do, or you can use whatever stride you can some up with, 14, 87, 1234344564, 47398573854734834, etc., it won't work because again, you could go around the curve and you won't know where the key lies or where to start your stride function from.

There is truly only one way to take advantage of a stride function; and I stated that months ago. My problem was, I could not create a stride function inside of CUDA. Or else I would have found 130's key already lol.

[Kamoheapohea]

I know you are used to spitting out random things and some are like ooooohhhhh ahhhhhhhhh, but you seldom listen lol.

He is just having a good time. Writing everything that comes to his mind here and creating alt accounts etc for additional drama . Why not.

How many keys/s do you need for your approach to work?

[WanderingPhilospher]

I know you are used to spitting out random things and some are like ooooohhhhh ahhhhhhhhh, but you seldom listen lol.

He is just having a good time. Writing everything that comes to his mind here and creating alt accounts etc for additional drama . Why not.

How many keys/s do you need for your approach to work?

If we are talking speed, I have a program (a variation of BitCrack) that will get around 400 MKey/s (per GPU) but honestly, that is to slow. I would like to get around 1,200 MKey/s (per card, low end 30xx card) and multiple cards per instance.

[Kamoheapohea]

If we are talking speed, I have a program (a variation of BitCrack) that will get around 400 MKey/s (per GPU) but honestly, that is to slow. I would like to get around 1,200 MKey/s (per card, low end 30xx card) and multiple cards per instance.

Ok I can help you with coding if I think it works. I also modified BitCrack and solved some of the early puzzles with pubkey.

[nomachine]

My problem was, I could not create a stride function inside of CUDA. Or else I would have found 130's key already lol.

Is there a built-in "stride" function specifically in the CUDA kernel? Or maybe there is a workaround in a grid-stride loop? Or do we have to write a new kernel?

[lordfrs]

You could be working in a 50 bit range or a 256 bit range; and you can subtract, divide, multiply, etc. whatever you want to do, or you can use whatever stride you can some up with, 14, 87, 1234344564, 47398573854734834, etc., it won't work because again, you could go around the curve and you won't know where the key lies or where to start your stride function from.

There is truly only one way to take advantage of a stride function; and I stated that months ago. My problem was, I could not create a stride function inside of CUDA. Or else I would have found 130's key already lol.

If you write the exact step code you want, there will be friends who will try to help. If you draw the algorithm flow diagram they can help you