Bitcoin Forum
February 18, 2025, 09:58:02 AM *
News: Community Awards voting is open
 
   Home   Help Search Login Register More  
Pages: « 1 ... 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 [158] 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 ... 369 »
  Print  
Author Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it  (Read 255273 times)
mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 164



View Profile WWW
August 12, 2023, 10:39:02 PM
 #3141

Interesting!! However, in this case, you're not skipping keys; you're transposing the range from 2000:6000 to 1000:3000, which results in the same number of keys.

you avoid keys if you use the pubkey corresponding to pk 2, you would omit the odd private keys.

digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
August 13, 2023, 01:16:30 AM
 #3142

Interesting!! However, in this case, you're not skipping keys; you're transposing the range from 2000:6000 to 1000:3000, which results in the same number of keys.

you avoid keys if you use the pubkey corresponding to pk 2, you would omit the odd private keys.
Why and how do you change the G? If you change the generator all the results will be incorrect for secp256k1 curve, maybe you mean to use a stride of 2, in order to skip 1 key between each jump,  or skip 2, well if you try that you will see that you are just skipping for example 33% of the range as well as reducing the probability of finding your target by 33%.

But there is a way to do the search for public key faster, first you need to subtract as many keys as you can to have a new and ideally small range key, then you could generate +1 billion offsets and -1 billion offsets to keep in a file for auto comparison, then you could use a stride in such a way that each stride never goes beyond 2 billion keys, that way you are certain each stride will definitely have a 100% chance of landing on one of the 2 billion saved public keys.

Now for someone with serious RAM and speed, they can generate +10 & -10 billion keys to check and use a bigger stride to search faster.😉

🖤😏
mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 164



View Profile WWW
August 13, 2023, 04:57:41 AM
 #3143

Interesting!! However, in this case, you're not skipping keys; you're transposing the range from 2000:6000 to 1000:3000, which results in the same number of keys.

you avoid keys if you use the pubkey corresponding to pk 2, you would omit the odd private keys.
Why and how do you change the G? If you change the generator all the results will be incorrect for secp256k1 curve, maybe you mean to use a stride of 2, in order to skip 1 key between each jump,  or skip 2, well if you try that you will see that you are just skipping for example 33% of the range as well as reducing the probability of finding your target by 33%.

But there is a way to do the search for public key faster, first you need to subtract as many keys as you can to have a new and ideally small range key, then you could generate +1 billion offsets and -1 billion offsets to keep in a file for auto comparison, then you could use a stride in such a way that each stride never goes beyond 2 billion keys, that way you are certain each stride will definitely have a 100% chance of landing on one of the 2 billion saved public keys.

Now for someone with serious RAM and speed, they can generate +10 & -10 billion keys to check and use a bigger stride to search faster.😉

Code:
pk= 1
pub_x= 79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
pub_y= 483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8

pub_dec_x= 55066263022277343669578718895168534326250603453777594175500187360389116729240
pub_dec_y= 32670510020758816978083085130507043184471273380659243275938904335757337482424


These are the standard bitcoin parameters (secp256k1).

# Elliptic curve parameters (secp256k1)

Code:
P = 2**256 - 2**32 - 977
N = 115792089237316195423570985008687907852837564279074904382605163141518161494337
A = 0
B = 7
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
G = (Gx, Gy)

Gx & Gy  correspond to pubkey from pk #1

if we change these by the pubkey(x,y) of pk #2

Code:
pk= 2
pub_x= c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5
pub_y= 1ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a

pub_dec_x= 89565891926547004231252920425935692360644145829622209833684329913297188986597
pub_dec_y= 12158399299693830322967808612713398636155367887041628176798871954788371653930

Code:
P = 2**256 - 2**32 - 977
N = 115792089237316195423570985008687907852837564279074904382605163141518161494337
A = 0
B = 7
Gx = 89565891926547004231252920425935692360644145829622209833684329913297188986597
Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930
G = (Gx, Gy)

we will get

Code:
pk=1
pub= 02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5

pk=2
pub= 02e493dbf1c10d80f3581e4904930b1404cc6c13900ee0758474fa94abe8c4cd13

pk=3
pub= 03fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556


2, 4, 6....

that's what I mean.

And as for the decrease in the range of the pubkey, I'm on to something, which since you didn't understand before, I prefer to reserve it for the future.


bestie1549
Jr. Member
*
Offline Offline

Activity: 75
Merit: 5


View Profile
August 13, 2023, 06:35:11 AM
 #3144

Interesting!! However, in this case, you're not skipping keys; you're transposing the range from 2000:6000 to 1000:3000, which results in the same number of keys.

you avoid keys if you use the pubkey corresponding to pk 2, you would omit the odd private keys.
Why and how do you change the G? If you change the generator all the results will be incorrect for secp256k1 curve, maybe you mean to use a stride of 2, in order to skip 1 key between each jump,  or skip 2, well if you try that you will see that you are just skipping for example 33% of the range as well as reducing the probability of finding your target by 33%.

But there is a way to do the search for public key faster, first you need to subtract as many keys as you can to have a new and ideally small range key, then you could generate +1 billion offsets and -1 billion offsets to keep in a file for auto comparison, then you could use a stride in such a way that each stride never goes beyond 2 billion keys, that way you are certain each stride will definitely have a 100% chance of landing on one of the 2 billion saved public keys.

Now for someone with serious RAM and speed, they can generate +10 & -10 billion keys to check and use a bigger stride to search faster.😉

I am pretty much interested in generating these offsets as explained here, when you speaking of RAM sizes I can get as much as 5 Ekeys/s on BSGS with a good amount of thread too.

We need to know how to start and the BSGS is just an example to give you the understanding of the available RAM.

what are the parameters to put in place and what codes or tools would be required to achieve that goal mentioned above?
digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
August 13, 2023, 04:39:42 PM
 #3145


what are the parameters to put in place and what codes or tools would be required to achieve that goal mentioned above?
I'm not a code/tool expert, and I'm pretty sure all the existing ones lack something, I don't know maybe BSGS can do what I said.
If I had a perfect idea I could have used it myself, I only type what comes to my mind, whether it's possible or doable currently, I don't know. Hints is what I can provide the best.😉

🖤😏
james5000
Jr. Member
*
Offline Offline

Activity: 69
Merit: 2


View Profile
August 13, 2023, 07:02:10 PM
 #3146

Well, the code using my strategy still needs something that I can't see now, but just like I saw the pattern with the powers of 2, I'm certain that I will see what's missing for it to be faster.

Currently, I will be working on #130, now that I finally understood how the BSGS works.
unpluggedcoin
Newbie
*
Offline Offline

Activity: 18
Merit: 0


View Profile
August 14, 2023, 08:21:33 AM
 #3147


what are the parameters to put in place and what codes or tools would be required to achieve that goal mentioned above?
I'm not a code/tool expert, and I'm pretty sure all the existing ones lack something, I don't know maybe BSGS can do what I said.
If I had a perfect idea I could have used it myself, I only type what comes to my mind, whether it's possible or doable currently, I don't know. Hints is what I can provide the best.😉

Here is the code doing exactly what digaran explained earlier... I used on puzzle 125, chant it when someone else found it. I am not optimistic of it! you can have it if you've huge ram... it works on more more of a simple phenomenon rather then complex... In the script checkpoint.txt file has only public key x coordinates in decimal format. Why only x because, if you have public  keys of private keys from 1 to 1 billion, they are actually two billion public keys, first billion from 1 to 1 billion and the last billion,, both billion have same x coordinate,, so kind of really big help there Grin... The script first loads the file checkpoints.txt. so in this file I kept 80 million public keys from 2 - 80000000. The file size was 5.88 GB, been running on 8 GB RAM system. Here is how script works with a simple example you can modify relevant figures in script as per your needs...
Suppose our public key has the private key of 87 (which we don't know obviously) we have checkpoints from 1-5 (which is really big if we compare 80 million with 125 puzzle key distance),, so what the script does it, is subtracts a set jump from pubkey and checks the resulting point within checkpoints, you can set your own jump.. suppose you want to set jump size as 20, here is how script works:

87-20=67 (not in checkpoints)
67-20=47  (not in checkpoints)
47-20=27(not in checkpoints)
27-20=7(not in checkpoints)
7-20=-13(not in checkpoints)

As you know the range you can set the step size to suite the range, in our case, it is suitable to have 5 steps if we choose its size as 20...

After finishing 5 stepts, the script subtracts 5 from 87 and saves the progress in j_value.txt file, after every iteration it changes the value in j_value.txt file. So if you shutdown or power goes off, next time script restarts from where it left...
After first iteration script subtract 10 from 87-10=77
(10 because you have first 5 and last 5)
next iteration is like
77-20=57 (not in checkpoints)
57-20=37  (not in checkpoints)
37-20=17(not in checkpoints)
17-20=-3(matched)
-3 is matching because its inverse point is 3 and both have same x coordinate...
If a match is found, the script save that point in results.txt file.
I forget to mention xy.txt file has the decimal x and y coordinate of puzzle pub key.
Here is whole script: Chill
Code:
Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 -1 # The proven prime
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field
Acurve = 0; Bcurve = 7 # These two defines the elliptic curve. y^2 = x^3 + Acurve * x + Bcurve
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
GPoint = (Gx,Gy) # This is our generator point. Trillions of dif ones possible

def modinv(a, n=Pcurve):
    lm, hm = 1, 0
    low, high = a % n, n
    while low > 1:
        ratio = high // low
        nm, new = hm - lm * ratio, high - low * ratio
        lm, low, hm, high = nm, new, lm, low
    return lm % n

def ECadd(a, b):
    if a == 'O':
        return b
    if b == 'O':
        return a
    if a == b:
        LamAdd = ((3 * a[0] * a[0] + Acurve) * modinv(2 * a[1], Pcurve)) % Pcurve
    else:
        LamAdd = ((b[1] - a[1]) * modinv(b[0] - a[0], Pcurve)) % Pcurve
    x = (LamAdd * LamAdd - a[0] - b[0]) % Pcurve
    y = (LamAdd * (a[0] - x) - a[1]) % Pcurve
    return (x, y)


def ECsub(a, b):
    if b == 'O':
        return a
    if isinstance(a, str):
        a = tuple(map(int, a.split()))
    if isinstance(b, str):
        b = tuple(map(int, b.split()))
    neg_b = (b[0], -b[1] % Pcurve)
    return ECadd(a, neg_b)


def ECmul(a, b):
    result = 'O'
    while b > 0:
        if b % 2 == 1:
            result = ECadd(result, a)
        a = ECadd(a, a)
        b = b // 2
    return result

# Read the x, y coordinates from xy.txt
with open("xy.txt", "r") as f:
    x, y = map(int, f.read().strip().split())
    point = (x, y)

# Read the checkpoint x-coordinates from checkpoints.txt
with open("checkpoints.txt", "r") as f:
    checkpoints = set(map(int, f.read().strip().split()))

filename_out = "results.txt"


sub_count = 0


# read the last value of j from file
try:
    with open("j_value.txt", "r") as f:
        last_j_value = int(f.readline())
except:
    last_j_value = 0

# loop for multiplication factor 0, 2, 4, 6, 8, 10, 12, 14, .......
found_match = False
for j in range(last_j_value, 10000001):
    if found_match:
        break
    sub_count = 160000000 * j
    for k in range(100001): # loop for 1lac subtract iterations
        if k == 0:  # first iteration
            pass
        else:
            sub_count += 212676479325586539664609129644855
        result = ECmul(GPoint, sub_count)
        result = ECsub(point, result)
        print(sub_count)
        if result[0] in checkpoints:
            with open(filename_out, "w") as f_out:
                subtractions = sub_count // 212676479325586539664609129644855
                f_out.write("{} {} {}".format(result[0], result[1], subtractions))
            found_match = True
            break
    # save the value of j to file after each iteration
    with open("j_value.txt", "w") as f:
        f.write(str(j))

7-20=-13(not in checkpoints)
MoreForUs
Newbie
*
Offline Offline

Activity: 17
Merit: 0


View Profile
August 14, 2023, 12:31:24 PM
 #3148

I have a script that’s searching for the private key of puzzles 66,67, and 68. Just by just by searching through the hex range 20000000000000000 - 2ffffffffffffffff
Same can be done with the rest of the addresses. I only have to search through 1 range, but I can search for 4 addresses all at once.
So puzzle 68 may be cracked before 66 🤷‍♂️
If anyone is interested let me know. I will definitely need more computer power. But it’s worth it.. I’ve already tested it with previous addresses. Works like a charm. https://ibb.co/jzZTHhV
mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 164



View Profile WWW
August 14, 2023, 03:29:15 PM
 #3149


what are the parameters to put in place and what codes or tools would be required to achieve that goal mentioned above?
I'm not a code/tool expert, and I'm pretty sure all the existing ones lack something, I don't know maybe BSGS can do what I said.
If I had a perfect idea I could have used it myself, I only type what comes to my mind, whether it's possible or doable currently, I don't know. Hints is what I can provide the best.😉

Here is the code doing exactly what digaran explained earlier... I used on puzzle 125, chant it when someone else found it. I am not optimistic of it! you can have it if you've huge ram... it works on more more of a simple phenomenon rather then complex... In the script checkpoint.txt file has only public key x coordinates in decimal format. Why only x because, if you have public  keys of private keys from 1 to 1 billion, they are actually two billion public keys, first billion from 1 to 1 billion and the last billion,, both billion have same x coordinate,, so kind of really big help there Grin... The script first loads the file checkpoints.txt. so in this file I kept 80 million public keys from 2 - 80000000. The file size was 5.88 GB, been running on 8 GB RAM system. Here is how script works with a simple example you can modify relevant figures in script as per your needs...
Suppose our public key has the private key of 87 (which we don't know obviously) we have checkpoints from 1-5 (which is really big if we compare 80 million with 125 puzzle key distance),, so what the script does it, is subtracts a set jump from pubkey and checks the resulting point within checkpoints, you can set your own jump.. suppose you want to set jump size as 20, here is how script works:

87-20=67 (not in checkpoints)
67-20=47  (not in checkpoints)
47-20=27(not in checkpoints)
27-20=7(not in checkpoints)
7-20=-13(not in checkpoints)

As you know the range you can set the step size to suite the range, in our case, it is suitable to have 5 steps if we choose its size as 20...

After finishing 5 stepts, the script subtracts 5 from 87 and saves the progress in j_value.txt file, after every iteration it changes the value in j_value.txt file. So if you shutdown or power goes off, next time script restarts from where it left...
After first iteration script subtract 10 from 87-10=77
(10 because you have first 5 and last 5)
next iteration is like
77-20=57 (not in checkpoints)
57-20=37  (not in checkpoints)
37-20=17(not in checkpoints)
17-20=-3(matched)
-3 is matching because its inverse point is 3 and both have same x coordinate...
If a match is found, the script save that point in results.txt file.
I forget to mention xy.txt file has the decimal x and y coordinate of puzzle pub key.
Here is whole script: Chill
Code:
Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 -1 # The proven prime
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field
Acurve = 0; Bcurve = 7 # These two defines the elliptic curve. y^2 = x^3 + Acurve * x + Bcurve
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
GPoint = (Gx,Gy) # This is our generator point. Trillions of dif ones possible

def modinv(a, n=Pcurve):
    lm, hm = 1, 0
    low, high = a % n, n
    while low > 1:
        ratio = high // low
        nm, new = hm - lm * ratio, high - low * ratio
        lm, low, hm, high = nm, new, lm, low
    return lm % n

def ECadd(a, b):
    if a == 'O':
        return b
    if b == 'O':
        return a
    if a == b:
        LamAdd = ((3 * a[0] * a[0] + Acurve) * modinv(2 * a[1], Pcurve)) % Pcurve
    else:
        LamAdd = ((b[1] - a[1]) * modinv(b[0] - a[0], Pcurve)) % Pcurve
    x = (LamAdd * LamAdd - a[0] - b[0]) % Pcurve
    y = (LamAdd * (a[0] - x) - a[1]) % Pcurve
    return (x, y)


def ECsub(a, b):
    if b == 'O':
        return a
    if isinstance(a, str):
        a = tuple(map(int, a.split()))
    if isinstance(b, str):
        b = tuple(map(int, b.split()))
    neg_b = (b[0], -b[1] % Pcurve)
    return ECadd(a, neg_b)


def ECmul(a, b):
    result = 'O'
    while b > 0:
        if b % 2 == 1:
            result = ECadd(result, a)
        a = ECadd(a, a)
        b = b // 2
    return result

# Read the x, y coordinates from xy.txt
with open("xy.txt", "r") as f:
    x, y = map(int, f.read().strip().split())
    point = (x, y)

# Read the checkpoint x-coordinates from checkpoints.txt
with open("checkpoints.txt", "r") as f:
    checkpoints = set(map(int, f.read().strip().split()))

filename_out = "results.txt"


sub_count = 0


# read the last value of j from file
try:
    with open("j_value.txt", "r") as f:
        last_j_value = int(f.readline())
except:
    last_j_value = 0

# loop for multiplication factor 0, 2, 4, 6, 8, 10, 12, 14, .......
found_match = False
for j in range(last_j_value, 10000001):
    if found_match:
        break
    sub_count = 160000000 * j
    for k in range(100001): # loop for 1lac subtract iterations
        if k == 0:  # first iteration
            pass
        else:
            sub_count += 212676479325586539664609129644855
        result = ECmul(GPoint, sub_count)
        result = ECsub(point, result)
        print(sub_count)
        if result[0] in checkpoints:
            with open(filename_out, "w") as f_out:
                subtractions = sub_count // 212676479325586539664609129644855
                f_out.write("{} {} {}".format(result[0], result[1], subtractions))
            found_match = True
            break
    # save the value of j to file after each iteration
    with open("j_value.txt", "w") as f:
        f.write(str(j))

7-20=-13(not in checkpoints)

If you use pubkey # 2 here

Code:
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424

and with scalar multiplication (double and add)
You would look for 2,4,6.... faster, in theory, but you must make adjustments in the code.

digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
August 14, 2023, 03:42:47 PM
 #3150


what are the parameters to put in place and what codes or tools would be required to achieve that goal mentioned above?
I'm not a code/tool expert, and I'm pretty sure all the existing ones lack something, I don't know maybe BSGS can do what I said.
If I had a perfect idea I could have used it myself, I only type what comes to my mind, whether it's possible or doable currently, I don't know. Hints is what I can provide the best.😉

Here is the code doing exactly what digaran explained earlier... I used on puzzle 125, chant it when someone else found it. I am not optimistic of it! you can have it if you've huge ram... it works on more more of a simple phenomenon rather then complex... In the script checkpoint.txt file has only public key x coordinates in decimal format. Why only x because, if you have public  keys of private keys from 1 to 1 billion, they are actually two billion public keys, first billion from 1 to 1 billion and the last billion,, both billion have same x coordinate,, so kind of really big help there Grin... The script first loads the file checkpoints.txt. so in this file I kept 80 million public keys from 2 - 80000000. The file size was 5.88 GB, been running on 8 GB RAM system. Here is how script works with a simple example you can modify relevant figures in script as per your needs...
Suppose our public key has the private key of 87 (which we don't know obviously) we have checkpoints from 1-5 (which is really big if we compare 80 million with 125 puzzle key distance),, so what the script does it, is subtracts a set jump from pubkey and checks the resulting point within checkpoints, you can set your own jump.. suppose you want to set jump size as 20, here is how script works:

87-20=67 (not in checkpoints)
67-20=47  (not in checkpoints)
47-20=27(not in checkpoints)
27-20=7(not in checkpoints)
7-20=-13(not in checkpoints)

As you know the range you can set the step size to suite the range, in our case, it is suitable to have 5 steps if we choose its size as 20...

After finishing 5 stepts, the script subtracts 5 from 87 and saves the progress in j_value.txt file, after every iteration it changes the value in j_value.txt file. So if you shutdown or power goes off, next time script restarts from where it left...
After first iteration script subtract 10 from 87-10=77
(10 because you have first 5 and last 5)
next iteration is like
77-20=57 (not in checkpoints)
57-20=37  (not in checkpoints)
37-20=17(not in checkpoints)
17-20=-3(matched)
-3 is matching because its inverse point is 3 and both have same x coordinate...
If a match is found, the script save that point in results.txt file.
I forget to mention xy.txt file has the decimal x and y coordinate of puzzle pub key.
Here is whole script: Chill
Code:
Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 -1 # The proven prime
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field
Acurve = 0; Bcurve = 7 # These two defines the elliptic curve. y^2 = x^3 + Acurve * x + Bcurve
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
GPoint = (Gx,Gy) # This is our generator point. Trillions of dif ones possible

def modinv(a, n=Pcurve):
    lm, hm = 1, 0
    low, high = a % n, n
    while low > 1:
        ratio = high // low
        nm, new = hm - lm * ratio, high - low * ratio
        lm, low, hm, high = nm, new, lm, low
    return lm % n

def ECadd(a, b):
    if a == 'O':
        return b
    if b == 'O':
        return a
    if a == b:
        LamAdd = ((3 * a[0] * a[0] + Acurve) * modinv(2 * a[1], Pcurve)) % Pcurve
    else:
        LamAdd = ((b[1] - a[1]) * modinv(b[0] - a[0], Pcurve)) % Pcurve
    x = (LamAdd * LamAdd - a[0] - b[0]) % Pcurve
    y = (LamAdd * (a[0] - x) - a[1]) % Pcurve
    return (x, y)


def ECsub(a, b):
    if b == 'O':
        return a
    if isinstance(a, str):
        a = tuple(map(int, a.split()))
    if isinstance(b, str):
        b = tuple(map(int, b.split()))
    neg_b = (b[0], -b[1] % Pcurve)
    return ECadd(a, neg_b)


def ECmul(a, b):
    result = 'O'
    while b > 0:
        if b % 2 == 1:
            result = ECadd(result, a)
        a = ECadd(a, a)
        b = b // 2
    return result

# Read the x, y coordinates from xy.txt
with open("xy.txt", "r") as f:
    x, y = map(int, f.read().strip().split())
    point = (x, y)

# Read the checkpoint x-coordinates from checkpoints.txt
with open("checkpoints.txt", "r") as f:
    checkpoints = set(map(int, f.read().strip().split()))

filename_out = "results.txt"


sub_count = 0


# read the last value of j from file
try:
    with open("j_value.txt", "r") as f:
        last_j_value = int(f.readline())
except:
    last_j_value = 0

# loop for multiplication factor 0, 2, 4, 6, 8, 10, 12, 14, .......
found_match = False
for j in range(last_j_value, 10000001):
    if found_match:
        break
    sub_count = 160000000 * j
    for k in range(100001): # loop for 1lac subtract iterations
        if k == 0:  # first iteration
            pass
        else:
            sub_count += 212676479325586539664609129644855
        result = ECmul(GPoint, sub_count)
        result = ECsub(point, result)
        print(sub_count)
        if result[0] in checkpoints:
            with open(filename_out, "w") as f_out:
                subtractions = sub_count // 212676479325586539664609129644855
                f_out.write("{} {} {}".format(result[0], result[1], subtractions))
            found_match = True
            break
    # save the value of j to file after each iteration
    with open("j_value.txt", "w") as f:
        f.write(str(j))

7-20=-13(not in checkpoints)

Really nice one, too bad I don't know how to run scripts, I'm just a windows person used to double click on exe files. 😅


Here is another idea, lets see if it can be done or has any merits to it.

If we know the exact start and end range of a public key, we could divide the end range by a number to reduce it down as much as possible, maybe making it a 6 digits number, now we only have to change our 6 digit number and multiply it by the number which we first divided our end range with, we need to change the numbers in a way that it never goes beyond our end range when multiplied.

Now, before doing that, we need to add and subtract 1 G to our target and divide the results by 2, e.g. if our target is 256, we add 1, 2, 3, 4 etc and divide them all by 2 also we will add n/2 to all the results just to be safe and keep all of the keys to compare with our multiplication result.  Eventually if we change our nonce, ( 6 digit number ) enough times and multiply it with powers of 2, 3 etc somewhere we should see a known key.

A simple example :

Start range 1, end range 512, our target is 95, now we divide 512 by 32 to get 16.

But first lets generate some offsets for our target.

Add 1 to 95 = 96/2 = 48
Add 3 to 95 = 98/2 = 49
Add 5 to 95 = 100/2 = 50
Sub 1 from 95 = 94/2 = 47
Sub 15 from 95 = 80/2 = 40

Now we have 48, 49, 50, 47 and 40, then we multiply 16 by 2, 3, 4, 5, 6, 7, etc until we see one of the keys above.

Imagine if we generate different offsets, like billions of them, then we could simply keep multiplying to find one of our targets.


This just came to my mind today, it's not cooked well , yet!😉

🖤😏
unpluggedcoin
Newbie
*
Offline Offline

Activity: 18
Merit: 0


View Profile
August 15, 2023, 04:37:11 PM
 #3151



Really nice one, too bad I don't know how to run scripts, I'm just a windows person used to double click on exe files. 😅


Just copy the code and paste in notepad and save it as myscript.py (it would run on python), save in your folder, open folder, type CMD in address bar above and press ENTER, command prompt terminal will open, type there
>python myscript.py
and hit enter the script will run, you'll see step or jumps prints, chill!
unpluggedcoin
Newbie
*
Offline Offline

Activity: 18
Merit: 0


View Profile
August 15, 2023, 04:46:17 PM
 #3152



Here is another idea, lets see if it can be done or has any merits to it.

If we know the exact start and end range of a public key, we could divide the end range by a number to reduce it down as much as possible, maybe making it a 6 digits number, now we only have to change our 6 digit number and multiply it by the number which we first divided our end range with, we need to change the numbers in a way that it never goes beyond our end range when multiplied.

Now, before doing that, we need to add and subtract 1 G to our target and divide the results by 2, e.g. if our target is 256, we add 1, 2, 3, 4 etc and divide them all by 2 also we will add n/2 to all the results just to be safe and keep all of the keys to compare with our multiplication result.  Eventually if we change our nonce, ( 6 digit number ) enough times and multiply it with powers of 2, 3 etc somewhere we should see a known key.

A simple example :

Start range 1, end range 512, our target is 95, now we divide 512 by 32 to get 16.

But first lets generate some offsets for our target.

Add 1 to 95 = 96/2 = 48
Add 3 to 95 = 98/2 = 49
Add 5 to 95 = 100/2 = 50
Sub 1 from 95 = 94/2 = 47
Sub 15 from 95 = 80/2 = 40

Now we have 48, 49, 50, 47 and 40, then we multiply 16 by 2, 3, 4, 5, 6, 7, etc until we see one of the keys above.

Imagine if we generate different offsets, like billions of them, then we could simply keep multiplying to find one of our targets.


This just came to my mind today, it's not cooked well , yet!😉

[/quote]

I already tried and test it and much more that I don't remember but when someone refer it I already know how it will slap our ass  Grin!
The reason this and every similar approach won't work is strictly due to the modular behaviour of calculations!
Which is why BSGS Kangaroo has thus far been the best approach which is increasing the chances of luck and meet at middle! However, any other way around addition and subtraction would not work trust me, BECAUSE there is no full stop, when your calculations go pass around the curve and completes a circle, it actually passes your assumed mark,, funny thing is IT WON'T RING A BELL OR SHOW ANY ALERT!!!!!!!! It would still be showing you the point and you'll be happy assuming it as per your assumption but it would change itself from being ODD to EVEN, thats where everyone go nuts when things don't work as per assumptions, elliptically speaking LOL!!
kalos15btc
Jr. Member
*
Offline Offline

Activity: 50
Merit: 1


View Profile
August 15, 2023, 05:13:06 PM
 #3153



Here is another idea, lets see if it can be done or has any merits to it.

If we know the exact start and end range of a public key, we could divide the end range by a number to reduce it down as much as possible, maybe making it a 6 digits number, now we only have to change our 6 digit number and multiply it by the number which we first divided our end range with, we need to change the numbers in a way that it never goes beyond our end range when multiplied.

Now, before doing that, we need to add and subtract 1 G to our target and divide the results by 2, e.g. if our target is 256, we add 1, 2, 3, 4 etc and divide them all by 2 also we will add n/2 to all the results just to be safe and keep all of the keys to compare with our multiplication result.  Eventually if we change our nonce, ( 6 digit number ) enough times and multiply it with powers of 2, 3 etc somewhere we should see a known key.

A simple example :

Start range 1, end range 512, our target is 95, now we divide 512 by 32 to get 16.

But first lets generate some offsets for our target.

Add 1 to 95 = 96/2 = 48
Add 3 to 95 = 98/2 = 49
Add 5 to 95 = 100/2 = 50
Sub 1 from 95 = 94/2 = 47
Sub 15 from 95 = 80/2 = 40

Now we have 48, 49, 50, 47 and 40, then we multiply 16 by 2, 3, 4, 5, 6, 7, etc until we see one of the keys above.

Imagine if we generate different offsets, like billions of them, then we could simply keep multiplying to find one of our targets.


This just came to my mind today, it's not cooked well , yet!😉


I already tried and test it and much more that I don't remember but when someone refer it I already know how it will slap our ass  Grin!
The reason this and every similar approach won't work is strictly due to the modular behaviour of calculations!
Which is why BSGS Kangaroo has thus far been the best approach which is increasing the chances of luck and meet at middle! However, any other way around addition and subtraction would not work trust me, BECAUSE there is no full stop, when your calculations go pass around the curve and completes a circle, it actually passes your assumed mark,, funny thing is IT WON'T RING A BELL OR SHOW ANY ALERT!!!!!!!! It would still be showing you the point and you'll be happy assuming it as per your assumption but it would change itself from being ODD to EVEN, thats where everyone go nuts when things don't work as per assumptions, elliptically speaking LOL!!
[/quote]


hi brother, if you are a newbie here,, and you just have that idea today come to your mind, just put in your mind something, there is a lot of professional users here, we did think of all possibilities, dont you think that we already think of your idea ? of course we did think of  a lot , do you have the right materiel hardware to do that Huh if you do than ok we are with you lmao, its impossible to do it bro,
if you exctrat billions, still terramillions remains ...
MoreForUs
Newbie
*
Offline Offline

Activity: 17
Merit: 0


View Profile
August 15, 2023, 05:29:10 PM
 #3154

I have a script that’s searching for the private key of puzzles 66,67, and 68. Just by just by searching through the hex range 20000000000000000 - 2ffffffffffffffff
Same can be done with the rest of the addresses. I only have to search through 1 range, but I can search for 4 addresses all at once.
So puzzle 68 may be cracked before 66 🤷‍♂️
If anyone is interested let me know. I will definitely need more computer power. But it’s worth it.. I’ve already tested it with previous addresses. Works like a charm. https://ibb.co/jzZTHhV

One of the best ways to do it 👌🏻
james5000
Jr. Member
*
Offline Offline

Activity: 69
Merit: 2


View Profile
August 15, 2023, 06:31:18 PM
 #3155

Where can I find CPUs for rent? Not GPUs, only CPUs?
MoreForUs
Newbie
*
Offline Offline

Activity: 17
Merit: 0


View Profile
August 15, 2023, 11:19:15 PM
 #3156

Where can I find CPUs for rent? Not GPUs, only CPUs?

Lamdalabs dot com
digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
August 15, 2023, 11:38:31 PM
 #3157


just put in your mind something, there is a lot of professional users here, we did think of all possibilities, dont you think that we already think of your idea ? of course we did think of  a lot
The quote above is a golden statement, I like the way you emphasize on "we".😅

You never know if an idea is possible to execute or not until either you or someone else puts it to test. Sorry if I offended your professional spirit.

🖤😏
bestie1549
Jr. Member
*
Offline Offline

Activity: 75
Merit: 5


View Profile
August 16, 2023, 06:13:01 AM
 #3158


just put in your mind something, there is a lot of professional users here, we did think of all possibilities, dont you think that we already think of your idea ? of course we did think of  a lot
The quote above is a golden statement, I like the way you emphasize on "we".😅

You never know if an idea is possible to execute or not until either you or someone else puts it to test. Sorry if I offended your professional spirit.

The sprit of idea is how powerful it is in the bearer's minds, someone else might hear it and see it as something impossible or otherwise stupid but only until it comes to past will they now believe that there is possibility in everything. Don't be surprised that the ideas sometimes thought to be possible are actually the ones that are impossible... for example: thinking Quantum computers would be able to break the ECC SECP256K1 curve someday... these ideas are the ones that should be erase from the minds or ignorant people. but unfortunately if you stack millions of GPUs in a single machine you'd gain momentum... the point is, millions of GPUs stacked together in a single machine doesn't mean that that's a quantum computer. It means you have enough resources. So likewise, good ideas are sometimes what the fools would never see any meaningful reasoning to, whereas they'd rather buy the false imaginations.

Don't stop sharing ideas brother, because sometimes, you only have the half of the full idea, someone else might have the remaining half and make it a full idea and not a "fool's idea" as Kalos had made it feel earlier.
kalos15btc
Jr. Member
*
Offline Offline

Activity: 50
Merit: 1


View Profile
August 16, 2023, 09:02:02 AM
 #3159


just put in your mind something, there is a lot of professional users here, we did think of all possibilities, dont you think that we already think of your idea ? of course we did think of  a lot
The quote above is a golden statement, I like the way you emphasize on "we".😅

You never know if an idea is possible to execute or not until either you or someone else puts it to test. Sorry if I offended your professional spirit.

The sprit of idea is how powerful it is in the bearer's minds, someone else might hear it and see it as something impossible or otherwise stupid but only until it comes to past will they now believe that there is possibility in everything. Don't be surprised that the ideas sometimes thought to be possible are actually the ones that are impossible... for example: thinking Quantum computers would be able to break the ECC SECP256K1 curve someday... these ideas are the ones that should be erase from the minds or ignorant people. but unfortunately if you stack millions of GPUs in a single machine you'd gain momentum... the point is, millions of GPUs stacked together in a single machine doesn't mean that that's a quantum computer. It means you have enough resources. So likewise, good ideas are sometimes what the fools would never see any meaningful reasoning to, whereas they'd rather buy the false imaginations.

Don't stop sharing ideas brother, because sometimes, you only have the half of the full idea, someone else might have the remaining half and make it a full idea and not a "fool's idea" as Kalos had made it feel earlier.



bro i said that because the newbie members always share the same idea, from years we see the same ideas and reply to it, please for newbie to read this and the other thread of the puzzle do not spam thats what i want to say
unpluggedcoin
Newbie
*
Offline Offline

Activity: 18
Merit: 0


View Profile
August 16, 2023, 01:27:04 PM
 #3160


bro i said that because the newbie members always share the same idea, from years we see the same ideas and reply to it, please for newbie to read this and the other thread of the puzzle do not spam thats what i want to say

I don't understand newbie preposition here! If you are referring me as new BIE than, I am happy to be it or even born bie if you like it! But the thing is we are all here making an effort to achieve a certain collective goal i guess. Someone posted logic, when I read it, I simply posted that Script that I developed probably 8 months ago, way before joining this forum! Well that didn't make me newbie there did it? Anyway, I shared my script, its simplest possible reasoning and logic behind,, the reason I said why digaran suggested formula won't work, the reason I commented on it because i tested it and tested it really hard not just spinning around! So basically I wanted to save someone's time pursuing something like that which has already proven to be waste of time, so that one can focus on other fresh ideas instead of wasting time on old ones!!! BTW how long one remains here a newBIE?Huh
Pages: « 1 ... 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 [158] 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 ... 369 »
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!