Bitcoin puzzle transaction ~32 BTC prize to who solves it

[David Dagher]

bro you know how this series genrated and what logic used behind this formula.
                         

                                          1
                                        11
                                      111
                                    1000
                                  10101
                                110001
                              1001100
                            11100000
           

not really I'm not very experienced in Python ..
are these the keys which were found for this puzzle? if yes please let me know.

[hr7864]

yes bro these key of puzzle if you have any idea how this series printed.

[David Dagher]

yes bro these key of puzzle if you have any idea how this series printed.

not really .. but I will check it out later .. I'm kind of busy nowadays ..

[jacky19790729]

python is too slow.....
https://github.com/Telariust/VanitySearch-bitcrack
I run VanitySearch, v1.15.4, now........
about  300000000 key/s  with 1 GTX1080

I will find 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN  private key  in 355832 days ( 974 years )  

0x0000000000000000000000000000000000000000000000008000000000000000
0x000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF

Code:

0xEE045BA02E5672B9,16jY7qLJnsZu4vZz2ceQcatusBAnXXRTBh,,,9 words match
0xEE072B6004228577,16jY7qLJnttAUrwnWVMu6DHHiE7Z17aQEr,,,9 words match
0xEDF9CD60356DCC19,16jY7qLJnx2ixrxCnTLSraerkgyB3YYAiT,,,10 words match

[David Dagher]

python is too slow.....
https://github.com/Telariust/VanitySearch-bitcrack
I run VanitySearch, v1.15.4, now........
about  300000000 key/s  with 1 GTX1080

I will find 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN  private key  in 355832 days ( 974 years )  

0x0000000000000000000000000000000000000000000000008000000000000000
0x000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFF

Code:

0xEE045BA02E5672B9,16jY7qLJnsZu4vZz2ceQcatusBAnXXRTBh,,,9 words match
0xEE072B6004228577,16jY7qLJnttAUrwnWVMu6DHHiE7Z17aQEr,,,9 words match
0xEDF9CD60356DCC19,16jY7qLJnx2ixrxCnTLSraerkgyB3YYAiT,,,10 words match

I don't have GPU

[Andzhig]

Hello,
I'm a total newbie for the bitcoin puzzle and bitcoin in general, but I have some experience in Python.
I wrote the following codes depending on my knowledge in Python.
first of all, I'm running these codes on 2 laptops [core i3 & core i5], but it runs extremely slow on both of them ~333keys/s
I tried to use Bitcrack but I couldn't manage to get it run on Kali Linux "I have just installed it couple of days ago so I'm not experienced with it"
I tried https://privatekeys.pw/scanner "which by the way shows that I'm generating ~15,000 Keys/s on both laptops!"
I tried to find a faster bitcoin library for Python but I couldn't manage to make it work like bitcoin standard library
anyway, here are my codes:
CODE #1

Code:

import random
from bitcoin import *
while True:
    x = random.randint(2**63, 2**64)
    y = privtoaddr(x)
    if y == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
        print(hex(i))
        break

CODE #2

Code:

from bitcoin import privtoaddr
i = 18446744073709551616
while i >= 9223372036854775808:
    i -= 1
    y = privtoaddr(i)
    if y == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
        print(hex(i))
        break

I try to play around a lot with CODE #2, but still getting the same results.
Any suggestions to make it run faster or recommending faster tools are appreciated.
Thanks in advance.

With your laptops speed, use BSGS by WanderingPhilospher https://bitcointalk.org/index.php?topic=5304368.0 or Plutus https://github.com/Isaacdelly/Plutus a slightly adapted one can check at least 20 million addr in 1 second (in infinity)...

***

and for this rubbish (sapper blade)

       1       2       3       4       5       6       7       8       9      10

0   [(0, 0)                                                                           1
1   [(1, 0), (0, 1)]                                                                  2
2   [(2, 0), (1, 1), (0, 2)]                                                          3
3   [(3, 0), (2, 1), (1, 2), (0, 3)]                                                  4
4   [(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]                                          5
5   [(5, 0), (4, 1), (3, 2), (2, 3), (1, 4), (0, 5)]                                  6
6   [(6, 0), (5, 1), (4, 2), (3, 3), (2, 4), (1, 5), (0, 6)]                          7
7   [(7, 0), (6, 1), (5, 2), (4, 3), (3, 4), (2, 5), (1, 6), (0, 7)]                  8
8   [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ]          9
9   [(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)]  10
10  [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)]          9
11  [(9, 2), (8, 3), (7, 4), (6, 5), (5, 6), (4, 7), (3, , (2, 9)]                  8
12  [(9, 3), (8, 4), (7, 5), (6, 6), (5, 7), (4, , (3, 9)]                          7
13  [(9, 4), (8, 5), (7, 6), (6, 7), (5, , (4, 9)]                                  6
14  [(9, 5), (8, 6), (7, 7), (6, , (5, 9)]                                          5
15  [(9, 6), (8, 7), (7, , (6, 9)]                                                  4
16  [(9, 7), (8, , (7, 9)]                                                          3
17  [(9, , (8, 9)]                                                                  2
18  [(9, 9)]                                                                          1


random search, step by step search...

import random
from bit import Key
import time

list = ["16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN","13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so","1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9"]


        #1       2        3       4       5       6       7       8       9      10

a0=   [(0, 0)]                                                                         # 1
a1=   [(1, 0), (0, 1)]                                                                 # 2
a2=   [(2, 0), (1, 1), (0, 2)]                                                         # 3
a3=   [(3, 0), (2, 1), (1, 2), (0, 3)]                                                 # 4
a4=   [(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]                                         # 5
a5=   [(5, 0), (4, 1), (3, 2), (2, 3), (1, 4), (0, 5)]                                 # 6
a6=   [(6, 0), (5, 1), (4, 2), (3, 3), (2, 4), (1, 5), (0, 6)]                         # 7
a7=   [(7, 0), (6, 1), (5, 2), (4, 3), (3, 4), (2, 5), (1, 6), (0, 7)]                 # 8
a8=   [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ]         # 9
a9=   [(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)] # 10
a10=  [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)]         # 9
a11=  [(9, 2), (8, 3), (7, 4), (6, 5), (5, 6), (4, 7), (3, , (2, 9)]                 # 8
a12=  [(9, 3), (8, 4), (7, 5), (6, 6), (5, 7), (4, , (3, 9)]                         # 7
a13=  [(9, 4), (8, 5), (7, 6), (6, 7), (5, , (4, 9)]                                 # 6
a14=  [(9, 5), (8, 6), (7, 7), (6, , (5, 9)]                                         # 5
a15=  [(9, 6), (8, 7), (7, , (6, 9)]                                                 # 4
a16=  [(9, 7), (8, , (7, 9)]                                                         # 3
a17=  [(9, , (8, 9)]                                                                 # 2
a18=  [(9, 9)]                                                                         # 1


while True:

    v1 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18]) #[a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18]
    v2 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v3 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v4 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v5 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v6 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v7 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v8 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v9 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v10= random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])

    print(len(v1),v1)
    print(len(v2),v2)
    print(len(v3),v3)
    print(len(v4),v4)
    print(len(v5),v5)
    print(len(v6),v6)
    print(len(v7),v7)
    print(len(v8),v8)
    print(len(v9),v9)
    print(len(v10),v10)

    ur = len(v1)*len(v2)*len(v3)*len(v4)*len(v5)*len(v6)*len(v7)*len(v8)*len(v9)*len(v10)
    print(len(v1),len(v2),len(v3),len(v4),len(v5),len(v6),len(v7),len(v8),len(v9),len(v10),"=",ur)
    time.sleep(3.0)
    count = 0
   
    if ur >=       1000000:
        if ur <= 150000000:
   
            i = 1
            while i<=ur:

                b1 = random.choice(v1)
                b2 = random.choice(v2)
                b3 = random.choice(v3)
                b4 = random.choice(v4)
                b5 = random.choice(v5)
                b6 = random.choice(v6)
                b7 = random.choice(v7)
                b8 = random.choice(v8)
                b9 = random.choice(v9)
                b10= random.choice(v10)
                #print(v1,v2,v3,v4,v5,v6,v7,v8,v9,v10)
                #print(b1,b2,b3,b4,b5,b6,b7,b8,b9,b10)
                ex = b1+b2+b3+b4+b5+b6+b7+b8+b9+b10
                #ex2 = (''.join(ex))
                g = str(ex[0])+str(ex[1])+str(ex[2])+str(ex[3])+str(ex[4])+str(ex[5])+str(ex[6])+str(ex[7])+str(ex[8])+str(ex[9])+str(ex[10])+str(ex[11])+str(ex[12])+str(ex[13])+str(ex[14])+str(ex[15])+str(ex[16])+str(ex[17])+str(ex[18])+str(ex[19])
                #print(g)
                time.sleep(0.02)
                ran = int(g)
                count += 1
                key1 = Key.from_int(ran)
                addr1 = key1.address
                                                                                       
                if addr1 in list:

                    print (ran,"found!!!")

                    s5 = str(ran)
                    f=open(u"C:/a.txt","a")
                    f.write(s5 + '\n')
                    f.close()

                    break

                else:
                                                                                               
                    #pass
                    print(len(v1),len(v2),len(v3),len(v4),len(v5),len(v6),len(v7),len(v8),len(v9),len(v10),"= random step",ur, count,ran,len(g),addr1)

                i=i+1

        #else:
            #pass
    #else:
        #pass

    pass

import random
from bit import Key
import time
import itertools

list = ["16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN","13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so","1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9"]



        #1       2        3       4       5       6       7       8       9      10

a0=   [(0, 0)]                                                                         # 1
a1=   [(1, 0), (0, 1)]                                                                 # 2
a2=   [(2, 0), (1, 1), (0, 2)]                                                         # 3
a3=   [(3, 0), (2, 1), (1, 2), (0, 3)]                                                 # 4
a4=   [(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]                                         # 5
a5=   [(5, 0), (4, 1), (3, 2), (2, 3), (1, 4), (0, 5)]                                 # 6
a6=   [(6, 0), (5, 1), (4, 2), (3, 3), (2, 4), (1, 5), (0, 6)]                         # 7
a7=   [(7, 0), (6, 1), (5, 2), (4, 3), (3, 4), (2, 5), (1, 6), (0, 7)]                 # 8
a8=   [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ]         # 9
a9=   [(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)] # 10
a10=  [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)]         # 9
a11=  [(9, 2), (8, 3), (7, 4), (6, 5), (5, 6), (4, 7), (3, , (2, 9)]                 # 8
a12=  [(9, 3), (8, 4), (7, 5), (6, 6), (5, 7), (4, , (3, 9)]                         # 7
a13=  [(9, 4), (8, 5), (7, 6), (6, 7), (5, , (4, 9)]                                 # 6
a14=  [(9, 5), (8, 6), (7, 7), (6, , (5, 9)]                                         # 5
a15=  [(9, 6), (8, 7), (7, , (6, 9)]                                                 # 4
a16=  [(9, 7), (8, , (7, 9)]                                                         # 3
a17=  [(9, , (8, 9)]                                                                 # 2
a18=  [(9, 9)]                                                                         # 1


while True:

    v1 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18]) #[a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18]
    v2 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v3 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v4 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v5 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v6 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v7 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v8 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v9 = random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])
    v10= random.choice([a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18])

    print(len(v1),v1)
    print(len(v2),v2)
    print(len(v3),v3)
    print(len(v4),v4)
    print(len(v5),v5)
    print(len(v6),v6)
    print(len(v7),v7)
    print(len(v8),v8)
    print(len(v9),v9)
    print(len(v10),v10)

    ur = len(v1)*len(v2)*len(v3)*len(v4)*len(v5)*len(v6)*len(v7)*len(v8)*len(v9)*len(v10)
    print(len(v1),len(v2),len(v3),len(v4),len(v5),len(v6),len(v7),len(v8),len(v9),len(v10),"=",ur)
    time.sleep(3.0)
    count = 0
   
    if ur >=       1000000:
        if ur <= 150000000:
           
            for x in itertools.product(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10):
                count += 1
                d = ("".join(map(str, (item for sublist in x for item in sublist))))

                ran = int(d)
                key1 = Key.from_int(ran)
                addr1 = key1.address
                                                                                       
                if addr1 in list:

                    print (ran,"found!!!")

                    s5 = str(ran)
                    f=open(u"C:/a.txt","a")
                    f.write(s5 + '\n')
                    f.close()

                    break

                else:
                                                                                               
                    #pass
                    print(len(v1),len(v2),len(v3),len(v4),len(v5),len(v6),len(v7),len(v8),len(v9),len(v10),"=",ur,count,ran,len(d),addr1) #("all steps",lenn,count,ran,len(d),addr1)

    pass

[fxsniper]

Hello,
I'm a total newbie for the bitcoin puzzle and bitcoin in general, but I have some experience in Python.
I wrote the following codes depending on my knowledge in Python.
first of all, I'm running these codes on 2 laptops [core i3 & core i5], but it runs extremely slow on both of them ~333keys/s
I tried to use Bitcrack but I couldn't manage to get it run on Kali Linux "I have just installed it couple of days ago so I'm not experienced with it"
I tried https://privatekeys.pw/scanner "which by the way shows that I'm generating ~15,000 Keys/s on both laptops!"
I tried to find a faster bitcoin library for Python but I couldn't manage to make it work like bitcoin standard library
anyway, here are my codes:
CODE #1

Code:

import random
from bitcoin import *
while True:
    x = random.randint(2**63, 2**64)
    y = privtoaddr(x)
    if y == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
        print(hex(i))
        break

CODE #2

Code:

from bitcoin import privtoaddr
i = 18446744073709551616
while i >= 9223372036854775808:
    i -= 1
    y = privtoaddr(i)
    if y == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
        print(hex(i))
        break

I try to play around a lot with CODE #2, but still getting the same results.
Any suggestions to make it run faster or recommending faster tools are appreciated.
Thanks in advance.

With your laptops speed, use BSGS by WanderingPhilospher https://bitcointalk.org/index.php?topic=5304368.0 or Plutus https://github.com/Isaacdelly/Plutus a slightly adapted one can check at least 20 million addr in 1 second (in infinity)...

try BSGS or other way use method calculate position address before scan

code #2 scan all  is 9 Quintillion  (9 billion of billion)  if you laptop can scan 1 billion per day and then need 9 billion days to scan on you laptop

so pure scan (raw brute force all) may be not work, it need to calculate something before scan

example
15446744073709551615
16446744073709551615
17446744073709551615
18446744073709551615

if you guess key on between 17446744073709551615 to 18446744073709551615 still =  1000000000000000000   =  1000000000* 1000000000

64bit pool now still scan to 1 Quintillion  from 9 Quintillion 
try to join pool to scan all 8 Quintillion leave

[Homeless_PhD]

Hello from Ukraine, guys. I have watched the crypto skyrocketing to the MOON and nearly fallen in depression thinking that purchasing just a 1 BTC for a ~ 3k$ (when it was possible) could already provide me my own flat and so i've found different BTC contest including this one.

My ideas and used scripts could be found here https://github.com/HomelessPhD/BTC32

I've seen some of you struggled with the need to reduce the interval of Private Keys for brutting - i've managed this problem using MATLAB\Octave script (just because it has useful Variable-Precision arithmetic AKA Big Numbers and thats was faster for me to use a familiar instrument, but in nearest future i could write a C program if it is reasonable). The main idea of that Github project is to bruteforce multiple "32 BTC puzzle" addresses within a series of tiny Private Keys intervals using BitCrack utility. There are lots of comments i've left, but i'm opened for questions and propositions.

By the way, thinking of patterns behind the Private Keys (that is also described on Github) - i've  presented Private Keys for each 32 BTC address as relative position inside its "all possible Private Keys interval" so called alpha parameter: PK_n = 2^(n-1) + rem, where rem taken from {0...2^(n-1)} forming alpha_n = (PK_n -2^(n-1)) / 2^(n-1). Alpha parameter for all Private Keys shows the relative position of the Private Key inside its interval of possible values and lies in interval of {0..1} for all BTC addresses.

The autocorrelation for alpha parameters (Private Keys in dimensionless form) looks like a classical noise do (just google it):
https://user-images.githubusercontent.com/80585811/111080604-e3520280-8507-11eb-839e-8ebd26ec61bb.png

Histograms (that at infinity should form a Probability Density Function - but we have have only ~60-70 points) show an interesting behavior at 0.3-0.5 and 0.6-0.8 (and specially 0.82-0.83).

https://user-images.githubusercontent.com/80585811/111080580-c4537080-8507-11eb-9cc3-2bb6096ca752.png

One may say that 0.3-0.5 and 0.6-0.8 are reasonable sub-intervals for searches, other could state that it is more probable to find a new Private Key at histogram minima rather than at its maxima (thinking that final histogram should form a uniform distribution) and the smartest i assume will notice pure randomness stating that all the next keys are nearly unrelated with known keys. I've tried to simulate keys distribution (see the github) -  the third variant could be true but do we have a choice?! We cant loop through all Private Keys - it will take ~>1000 years for #64 and much more for others so one way or another, we will have to choose a criterion for narrowing the interval of Private Keys - histogram is one of such.


I am the last year PhD on applied physics. Now i need to hurry in writing a few more articles and I cant spent much time on this "hackaton" at the moment, but after researches and two articles (expect it will take a month) i'll return to this topic - wish you good luck. By the way, i've searched few interesting intervals (interesting alpha values) - you may find them in "Examples" folder on github.

P.S. Thank you for reading my post - it is my first post in bitcointalk. Sorry for my bad English.

[WanderingPhilospher]

Hello from Ukraine, guys. I have watched the crypto skyrocketing to the MOON and nearly fallen in depression thinking that purchasing just a 1 BTC for a ~ 3k$ (when it was possible) could already provide me my own flat and so i've found different BTC contest including this one.

My ideas and used scripts could be found here https://github.com/HomelessPhD/BTC32

I am the last year PhD on applied physics and. Now i need to hurry in writing a few more articles and I cant spent much time on this "hackaton" at the moment, but after researches and two articles (expect it will take a month) i'll return to this topic - wish you good luck. By the way, i've searched few interesting intervals (interesting alpha values) - you may found them in "Examples" folder on github.

P.S. Thank you for reading my post - it is my first post in bitcointalk. Sorry for my bad English.

Wow, very in depth process that you have on github. I may need to pick your brain on running larger widths in the ranges.

[fxsniper]

any useful for some formula on this video help to calculate where is address

seem many formula not easy to calculate still have part request to guess predict

old video
https://www.youtube.com/watch?v=f2s3_UG9IPU

[PawGo]

Histograms (that at infinity should form a Probability Density Function - but we have have only ~60-70 points) show an interesting behavior at 0.3-0.5 and 0.6-0.8 (and specially 0.82-0.83).

Priviet!

I did something like this long time ago (https://bitcointalk.org/index.php?topic=1306983.msg54879435#msg54879435)
BUT: it makes no sense!
Somewhere (I do not have time to search for the post) author stated that he generated random private keys and then replaced the beginning with ZEROs, just to keep incrementing ranges. So any statistical approach is useless IMHO.

[Homeless_PhD]

Histograms (that at infinity should form a Probability Density Function - but we have have only ~60-70 points) show an interesting behavior at 0.3-0.5 and 0.6-0.8 (and specially 0.82-0.83).

Priviet!

I did something like this long time ago (https://bitcointalk.org/index.php?topic=1306983.msg54879435#msg54879435)
BUT: it makes no sense!
Somewhere (I do not have time to search for the post) author stated that he generated random private keys and then replaced the beginning with ZEROs, just to keep incrementing ranges. So any statistical approach is useless IMHO.

Sure thing - i've also noted that on github https://github.com/HomelessPhD/BTC32 (making some dummy simulation showing histogram for the first 60s points and last 100 point of the group), but again, currently we have no other criterion for reducing\choosing intervals.

We could try to hack the Random Generator used to generate the sequence - that should be a "Algorithmic" random generator i assume - but that's probably even harder than 32 BTC puzzle task.

(should remember that there is no strong proof that inverse problem for both Random Generator or Private Key -> Public Key -> Address have no algorithmic solution, who knows, may be some smart, well motivated person with enough free time will find\construct an algorithm of reverse "de-hashing".)

[fxsniper]

I am interesting to run this code

someone know about code python language

please help to fix it

I try to fix it but not yet success

code old 2 year, now library keras is update to new version some function call it not working


https://bitcointalk.org/index.php?topic=5075651.0

https://github.com/btc-room101/bitcoin-rnn

[Andzhig]

I am interesting to run this code

someone know about code python language

please help to fix it

I try to fix it but not yet success

code old 2 year, now library keras is update to new version some function call it not working


https://bitcointalk.org/index.php?topic=5075651.0

https://github.com/btc-room101/bitcoin-rnn

Try old versions from 2018 to install https://pypi.org/project/Keras/#history pip install Keras==2.2.4 or 2.2.3 etc...

For the stupid what he does?

[jerrison]

The idea of solving complex algorithms supposedly for a computer and in reward for a 32 bitcoin units award, i will say its almost impossible. You aer talking about a reward system that exceeds 1.6 million dollars and one should look that way as a reality even in the face of bitoin scarcity? All should avoind this please.

[WanderingPhilospher]

The idea of solving complex algorithms supposedly for a computer and in reward for a 32 bitcoin units award, i will say its almost impossible. You aer talking about a reward system that exceeds 1.6 million dollars and one should look that way as a reality even in the face of bitoin scarcity? All should avoind this please.

You may want to actually read what this thread/32BTC challenge is actually about...

[DoinSomeStuff]

I am interesting to run this code

someone know about code python language

please help to fix it

I try to fix it but not yet success

code old 2 year, now library keras is update to new version some function call it not working


https://bitcointalk.org/index.php?topic=5075651.0

https://github.com/btc-room101/bitcoin-rnn

Try old versions from 2018 to install https://pypi.org/project/Keras/#history pip install Keras==2.2.4 or 2.2.3 etc...

For the stupid what he does?

Trying to find patterns of pubkey => privkey or pubkey hashed to privkey.
I've tried couple diffrent types of neural networks to solve that, but its requares massive data size, so its comparing to bruteforce, its not helpfull here.

[indoarts]

@fxsniper

Here is the code I told you I would upload.  It's not the exact one I was looking for but it is based on the same principle.  Easy to change the range you want to search through. I modified my code to search for the RIPEMD of the address I was looking for. Shaves a few milliseconds off versus processing all the way to the address. I created this probably 6 months ago and I am sure it is not the most efficient coding.  Hopefully it gives you some ideas on how to tweak and make exactly what you are wanting.

Code:

#Amateur, very amateur coding by the Wandering Philosopher
#Tested with Python 2.7
import binascii, hashlib, base58, sys, ecdsa, codecs, os, random
import time
import timeit
#Enter the RIPEMD160 of the address you want to search for; make sure it is in LOWERCASE
ripetofind = '3ee4133d991f52fdf6a25c9834e0745ac74248a4'

def compressed_RIPEMD(privkey):
    start_time = timeit.default_timer()
    pvk_to_bytes = codecs.decode (privkey, 'hex')
    
    #Generates the public key
    key = ecdsa.SigningKey.from_string (pvk_to_bytes, curve=ecdsa.SECP256k1).verifying_key
    key_bytes = key.to_string()
    key_hex = codecs.encode(key_bytes, 'hex')

    if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):
        #If the last byte of Y is Even, add '02'
        public_key_compressed = '02' + key_hex[0:64]

        #Making SHA-256 of compressed pubkey and then RIPEMD-160
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()

        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        
    else:
        #If the last byte of Y is Odd, add '03'
        public_key_compressed = '03' + key_hex[0:64]

        #Making SHA-256 of compressed pubkey and then RIPEMD-160
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()

        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        elapsed = timeit.default_timer() - start_time
        #Prints status and numbers on screen. Comment out both sys.stdout lines below if not wanted and the countall +=1 ; I liked to know it was working/running.
        sys.stdout.write("\r" + "  Key every: " + str(elapsed)[:7] + " seconds " + " Random RIPEMD160s:  " + ripemd160_hex + "   # of Keys: "  + str(countall))
        sys.stdout.flush()
        fwrite = open('KEYSFOUND.txt', 'a')
        if ripemd160_hex == ripetofind:
            fwrite.write('Key: ' + randomprivkey + '  ' + ripemd160_hex + '\n' )

#Always leave countall = 0 below. If you want the program to run unlimited, comment out the countall +=1 down below
countall = 0
while (countall < 100000000000000):
    if __name__== "__main__":
        
        #Enter the range you want to search through below
        low  = 0x8000000000000000
        high = 0xFFFFFFFFFFFFFFFF
        #high = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140
        randomprivkey = hex( random.randrange( low, high ) ).lstrip("0x").rstrip("L").zfill(64)
        countall +=1
        compressed_RIPEMD(randomprivkey)

can we put  additional code like " with open("my_ripemd _key.txt", "r") ? " cause i have tons of Ripemd address here ?
Regards

[Markzuberg64]

Can someone tell what exact happens in bsgs and kangaroo. In layman terms and by giving some examples. If possible please explain by example of any 10 bit 20 bit key so it can be understood easily. Like if i take a 64 bit known pub key and starts my bsgs or kangaroo , then what happens inside it. I understood that it uses pubkey + n*G to calculate anoher pubkey and if value of prv key related to this new pubkey is known then prv key for the input key can be calculated.  but how that helps. We still have to go through billions of keys and keypairs. How it generated those keypairs first. Secondly how it can be so fast to search for 64 bit in some seconds. Its still a large space. Confused ...

[fxsniper]

Can someone tell what exact happens in bsgs and kangaroo. In layman terms and by giving some examples. If possible please explain by example of any 10 bit 20 bit key so it can be understood easily. Like if i take a 64 bit known pub key and starts my bsgs or kangaroo , then what happens inside it. I understood that it uses pubkey + n*G to calculate anoher pubkey and if value of prv key related to this new pubkey is known then prv key for the input key can be calculated.  but how that helps. We still have to go through billions of keys and keypairs. How it generated those keypairs first. Secondly how it can be so fast to search for 64 bit in some seconds. Its still a large space. Confused ...

Did you read description explain on JeanLucPons Kangaroo at github already? try read for understand
https://github.com/JeanLucPons/Kangaroo