Author

Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 267. (Read 243769 times)

newbie
Activity: 10
Merit: 0

Code:
import sys
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice

print('\n      B I N A R Y   S E E D   S C A N   Q U A D R O   \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
    x1 = (x0+n)
    a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
    a1 = (a1)[2:]
    for i in range(x):
        a0 = str("1")            
        a2 = str("0")
        a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
        a3 = (a3)[3:]#.zfill(44)
        a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
        a4 = (a4)[3:]#.zfill(44)
        a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
        a5 = (a5)[3:]#.zfill(44)
        a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
        a6 = (a6)[3:]#.zfill(44)
        binb = "".join(a0+a1+a2+a3)
        binc = "".join(a0+a1+a2+a4)
        bind = "".join(a0+a1+a2+a5)
        bine = "".join(a0+a1+a2+a6)
        list.append(binb)
        list.append(binc)
        list.append(bind)
        list.append(bine)
        if len(list)==x:
            line_count=0
            for bina in (list):
                bina!='\n'
                addr = ice.privatekey_to_address(0, True, int(bina,2))
                line_count+=1
                                
                if addr.startswith('16jY7'): # 16jY7
                    ran = int(bina,2)
                    print('',bina, '\n')
                    sys.stdout.write('\r ' + hex(ran))
                    sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
                    sleep(1)
                    sys.stdout.write('\n\n continue...\n\n')
                    sleep(1)

                if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                    ran = int(bina,2)
                    print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
                    file=open(u"16j.Target.Info.txt","a")
                    file.write('\n ' + hex(ran) + ' | ' + addr)
                    file.close()
                    sleep(2)
                    wait = input("Press Enter to Exit.")
                    sleep(1)
                    exit()
                    
                if line_count==x:
                    list.clear()
                    
        if len(list)==0:
            print(' scan... ', str(n), end='\r')                        

Ca 42000 keys/s from c000000000000000 to ffffffffffffffff... The sector between  11_________________0 comprise a range of 131071 and will be processed.
The rest of this line are random numbers from 4 different generators..
The counter reflects the number of loops...

      B I N A R Y   S E E D   S C A N   Q U A D R O

 11_________________0____________________________________________

 1110010110110011011010011110001111111110100110111011100101000111

 0xe5b369e3fe9bb947 | 16jY7mM6wrpuAy53vKkh7QXm1JNdWK9Myu 19

 continue...

 1110010011000111001010001111000110100111001000001001110001000100

 0xe4c728f1a7209c44 | 16jY7Ezk5et98CVBWYEigGRwWovzhEtaQ3 121

 continue...

 scan...  192



B I N A R Y   S E E D   S C A N   Q U A D R O   

 11_________________0____________________________________________

Traceback (most recent call last):
  File "11.py", line 41, in
    addr = ice.privatekey_to_address(0, True, int(bina,2))
AttributeError: module 'secp256k1' has no attribute 'privatekey_to_address'
jr. member
Activity: 49
Merit: 1

Code:
import sys
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice

print('\n      B I N A R Y   S E E D   S C A N   Q U A D R O   \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
    x1 = (x0+n)
    a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
    a1 = (a1)[2:]
    for i in range(x):
        a0 = str("1")            
        a2 = str("0")
        a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
        a3 = (a3)[3:]#.zfill(44)
        a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
        a4 = (a4)[3:]#.zfill(44)
        a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
        a5 = (a5)[3:]#.zfill(44)
        a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
        a6 = (a6)[3:]#.zfill(44)
        binb = "".join(a0+a1+a2+a3)
        binc = "".join(a0+a1+a2+a4)
        bind = "".join(a0+a1+a2+a5)
        bine = "".join(a0+a1+a2+a6)
        list.append(binb)
        list.append(binc)
        list.append(bind)
        list.append(bine)
        if len(list)==x:
            line_count=0
            for bina in (list):
                bina!='\n'
                addr = ice.privatekey_to_address(0, True, int(bina,2))
                line_count+=1
                                
                if addr.startswith('16jY7'): # 16jY7
                    ran = int(bina,2)
                    print('',bina, '\n')
                    sys.stdout.write('\r ' + hex(ran))
                    sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
                    sleep(1)
                    sys.stdout.write('\n\n continue...\n\n')
                    sleep(1)

                if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                    ran = int(bina,2)
                    print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
                    file=open(u"16j.Target.Info.txt","a")
                    file.write('\n ' + hex(ran) + ' | ' + addr)
                    file.close()
                    sleep(2)
                    wait = input("Press Enter to Exit.")
                    sleep(1)
                    exit()
                    
                if line_count==x:
                    list.clear()
                    
        if len(list)==0:
            print(' scan... ', str(n), end='\r')                        

Ca 42000 keys/s from c000000000000000 to ffffffffffffffff... The sector between  11_________________0 comprise a range of 131071 and will be processed.
The rest of this line are random numbers from 4 different generators..
The counter reflects the number of loops...

      B I N A R Y   S E E D   S C A N   Q U A D R O

 11_________________0____________________________________________

 1110010110110011011010011110001111111110100110111011100101000111

 0xe5b369e3fe9bb947 | 16jY7mM6wrpuAy53vKkh7QXm1JNdWK9Myu 19

 continue...

 1110010011000111001010001111000110100111001000001001110001000100

 0xe4c728f1a7209c44 | 16jY7Ezk5et98CVBWYEigGRwWovzhEtaQ3 121

 continue...

 scan...  192
jr. member
Activity: 49
Merit: 1
jeniferangel79,

take a look at when the puzzle is from and what the BTC was worth at that time... surely there is a reason, security plays a big role in the crypto universe... and see what and how far the programmers get solving the puzzle is certainly an interesting aspect for future crypto projects... ^^
newbie
Activity: 86
Merit: 0
How about you ask Robert Langdon, I heard he is very great at something like this Well the arrangement doesn't sound good to me at this point yet will attempt with it somewhat more later. Regardless, I don't figure somebody will give out 32 BTC just to address some riddle... there should be something different that we don't have the foggiest idea or can't see.
Sherlock to protect perhaps?
full member
Activity: 431
Merit: 105
whats the ice jolly jocker. paste code pls
jr. member
Activity: 49
Merit: 1
with "ice" to address.. 42500 keys/s ... nice one!!


              ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN==============


 11%|██████                                            | 115508/1048576 [00:02<00:21, 42521.10it/s]



I will work on it to make it faster...I will see the 3.5 Million Keys/s Speed... in combination with such scanners..


"[faster "bit" there is a library from "ice" https://github.com/iceland2k14/secp256k1 there it is necessary to throw its libraries into the folder with the script.]"

Code:

import sys
import random
import secp256k1 as ice
from time import sleep
from tqdm import tqdm
print('\n              ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN============== \n\n')
x=1048576
list=[]
print(' WAIT!....', end='\r')
while x:
    b01 = random.choice("0123456789abcdef")
    b02 = random.choice("0123456789abcdef")
    b03 = random.choice("0123456789abcdef")
    b04 = random.choice("0123456789abcdef")
    b05 = random.choice("0123456789abcdef")
    b06 = random.choice("0123456789abcdef")
    b07 = random.choice("0123456789abcdef")
    b08 = random.choice("0123456789abcdef")
    b09 = random.choice("0123456789abcdef")
    b10 = random.choice("0123456789abcdef")
    b11 = random.choice("0123456789abcdef")
    b12 = random.choice("0123456789abcdef")
    b13 = random.choice("0123456789abcdef")
    b14 = random.choice("0123456789abcdef")
    b15 = random.choice("0123456789abcdef")
   
    hex = (b01+b02+b03+b04+b05+b06+b07+b08+b09+b10+b11+b12+b13+b14+b15)
    hex8 = '8'+ hex
    list.append(hex8)
    hex9 = '9'+ hex
    list.append(hex9)
    hexa = 'a'+ hex
    list.append(hexa)
    hexb = 'b'+ hex
    list.append(hexb)
    hexc = 'c'+ hex
    list.append(hexc)
    hexd = 'd'+ hex
    list.append(hexd)
    hexe = 'e'+ hex
    list.append(hexe)
    hexf = 'f'+ hex
    list.append(hexf)
    if len(list)==x:   
        line_count=0
        for line0 in tqdm(list):
            line0!='\n'             
            line_count+=1
         #  line = int(line0, 16)
         #  a = len(bin(line))-2
            addr = ice.privatekey_to_address(0, True, int(line0, 16))                               
         #  sys.stdout.write('\r scanning.... [' + (line0) + '] ' + str(a) + ' bit ')
                       
            if addr.startswith('16jY7'): # 16jY7q
                sys.stdout.write('\n\n ' + line0 + ' | ' + addr)
                sleep(1)
                sys.stdout.write('\n\n continue...\n\n')
                sleep(1)

            if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                print('\n\n Target found!!' + line0 + ' \n ' + addr,'\n')
                file=open(u"16j.Target.Info.txt","a")
                file.write('\n ' + line0 + '| ' + addr)
                file.close()
                sleep(2)
                wait = input("Press Enter to Exit.")
                sleep(1)
                exit()
               
            if line_count==x:
                list.clear()
               
    if len(list)==0:
        print('\n WAIT!....\n')

jr. member
Activity: 184
Merit: 3
faster "bit" there is a library from "ice" https://github.com/iceland2k14/secp256k1 there it is necessary to throw its libraries into the folder with the script.

***

and read (with a translator) https://istina.msu.ru/profile/FilatovOV/ , https://vk.com/@fil_post-eta-statya-rvet-vse-predstavleniya-o-veroyatnostyah , https://disk.yandex.ru/i/LsEWmhs3ArM7Tw

Quote
This article breaks all ideas about probabilities.

Everyone knows that it is impossible to guess the sides of a coin, but this article will show a mechanism that allows you to predict the sides of a coin, that is, you can actually guess. First, I will briefly describe the traditional way of working with probabilities, working in this way does not allow you to predict the sides of the coin. And then, in the same terse way, I will describe the way I discovered to work with probability, which allows you to predict the loss of the sides of the coin.

And so, the coin was tossed many times N and the result of its loss formed a sequence of ones and zeros. Let's determine the average length of a drop-down series of repeating identical events, for example: "00000.." or "11111.." in our large series of N flips.

It is described here: how to look at a random sequence so that the probabilities of guessing and not guessing are equal.

The traditional way to determine the average length of outliers from repeating identical events is to sequentially look through all the recorded values ​​and accurately count the number of runs of detected lengths.

The total number of series of unit lengths: "0" and "1" will be N/4. The total number of series of length two: "00" and "11" will be N/8. The total number of series of length three: "000" and "111" will be N/16. The total number of series of length four: "0000" and "1111" will be N/32. Etc. Of course, the detected numbers of series are unlikely to be exactly equal to the calculated values, since, despite the frequency stability, there are still random probabilistic fluctuations in the actual number of events around the theoretically obtained mats.expectations. Taking into account all elementary events N of our sequence, we find that the total number of all our series ("0" + "1" + "00" + "11" + "000" + "111" + ...) is equal to N / 2 (again up to random fluctuations). Now let's solve the problem: to determine the average length of the drop-down series, for this we need to divide the number of members of the sequence N by the sum of all series N / 2. Divide N / (N/2) = 2. That is, we found that the average length of a series with the traditional way of looking at and guessing the sides of a coin is two. That is, with an average length of a consecutive series of two events, it is impossible to guess the fallout of the sides. Obviously, if the average length of a consecutive series ("0"; "1"; "00"; "11"; "000"; "111"; ...) were three events, then we would begin to guess the fallout of the sides of the coin much more often than not guessing. Let's now look at my way of getting the average event length, which is three.

It describes how to look at a random sequence so that the probabilities of guessing and not guessing become different.

In order to influence the probability, it is necessary to change the average length of a series of events falling out in a row. This is achieved by applying a well-known geometric probability to the guessing process.
The principle of geometric probability states that objects with a larger size are hit more often than objects with a smaller size. With regard to our random sequence N, this means that if we count, for example, every hundredth member of the sequence and determine the length of the series ("0"; "1"; "00"; "11"; "000"; "111"; ... ) to which it belongs, it turns out that the frequency of hits of every hundredth event in long series increased, and decreased in short series.

That is, the average length of the detected series, in the case of a geometric set of statistics, will become equal to three. And it is precisely this increase in the average length of a series from two events (with sequential counting of each event) to three events (with gaps of sufficient length between guesses) that makes it possible to guess the side of the dropped coin more often than in half of the predictions. Here, now, I have described the fundamental principle of geometric probability, in relation to changing the average length of the found series in a random binary sequence.


he has studies of random events, sequences, there are formulas, I still don’t understand everything, he launches a probe there into a file with 20000000 random bits and...

pz64 ripmd160 hex to bin 1111101110010000010011001111011001100100011111010100101111110111110110101000100 1011100100110000011010011100000011101000101101011000111010000100100100010100100

11111 0 111 00 1 00000 1 00 11 00 1111 0 11 00 11 00 1 000 11111 0 1 0 1 00 1 0 111111 0 11111 0 11 0 1 0 1 000 1 00 1 0 111 00 1 00 11 00000 11 0 1 00 111 000000 111 0 1 000 1 0 11 0 1 0 11 000 111 0 1 0000 1 00 1 00 1 000 1 0 1 00 1 00

1       22
11      8
111     5
1111    1
11111   3
111111  1
1111111
11111111

0       17
00      14
000     5
0000    1
00000   2
000000  1
0000000
00000000

0, 1 - elementary events, they make waves 111 000 1111 0000... when nearby the same half-wavelength 111000 11110000...  

Quote
In order to influence the probability, it is necessary to change the average length of a series of events falling out in a row. This is achieved by applying a well-known geometric probability to the guessing process.
The principle of geometric probability states that objects with a larger size are hit more often than objects with a smaller size. With regard to our random sequence N, this means that if we count, for example, every hundredth member of the sequence and determine the length of the series ("0"; "1"; "00"; "11"; "000"; "111"; ... ) to which it belongs, it turns out that the frequency of hits of every hundredth event in long series increased, and decreased in short series.
what does this mean? we can run over the 2^256 range and generate these bit sets over several hashes...
jr. member
Activity: 49
Merit: 1
A fast scanner that completely covers the 64-bit range with more than 12000 keys/s (depending on the CPU clock) with Intel Xeon E3-1240 V2 @ 3.40GHz (13500 keys/s)

Code:
import sys
import random
from bit import *
from time import sleep
from tqdm import tqdm
print('\n              ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN============== \n\n')
x=1048576
list=[]
print(' WAIT!....', end='\r')
while x:
    b01 = random.choice("0123456789abcdef")
    b02 = random.choice("0123456789abcdef")
    b03 = random.choice("0123456789abcdef")
    b04 = random.choice("0123456789abcdef")
    b05 = random.choice("0123456789abcdef")
    b06 = random.choice("0123456789abcdef")
    b07 = random.choice("0123456789abcdef")
    b08 = random.choice("0123456789abcdef")
    b09 = random.choice("0123456789abcdef")
    b10 = random.choice("0123456789abcdef")
    b11 = random.choice("0123456789abcdef")
    b12 = random.choice("0123456789abcdef")
    b13 = random.choice("0123456789abcdef")
    b14 = random.choice("0123456789abcdef")
    b15 = random.choice("0123456789abcdef")
   
    hex = (b01+b02+b03+b04+b05+b06+b07+b08+b09+b10+b11+b12+b13+b14+b15)
    hex8 = '8'+ hex
    list.append(hex8)
    hex9 = '9'+ hex
    list.append(hex9)
    hexa = 'a'+ hex
    list.append(hexa)
    hexb = 'b'+ hex
    list.append(hexb)
    hexc = 'c'+ hex
    list.append(hexc)
    hexd = 'd'+ hex
    list.append(hexd)
    hexe = 'e'+ hex
    list.append(hexe)
    hexf = 'f'+ hex
    list.append(hexf)
    if len(list)==x:   
        line_count=0
        for line0 in tqdm(list):
            line0!='\n'             
            line_count+=1
            line = int(line0, 16)
            a = len(bin(line))-2
            key = Key.from_int(line)
            addr = key.address                                       
         #  sys.stdout.write('\r scanning.... [' + (line0) + '] ' + str(a) + ' bit ')
                       
            if addr.startswith('16jY7'): # 16jY7q
                sys.stdout.write('\n\n ' + line0 + ' | ' + addr)
                sleep(1)
                sys.stdout.write('\n\n continue...\n\n')
                sleep(1)

            if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                print('\n\n Target found!!' + line0 + ' \n ' + addr,'\n')
                file=open(u"16j.Target.Info.txt","a")
                file.write('\n ' + line0 + '| ' + addr)
                file.close()
                sleep(2)
                wait = input("Press Enter to Exit.")
                sleep(1)
                exit()
               
            if line_count==x:
                list.clear()
               
    if len(list)==0:
        print('\n WAIT!....\n')
newbie
Activity: 10
Merit: 0
Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?


Why would you want the binary value over hex?

I think the scanning process will be faster.

No it won't, python interpreter represents these numbers in the exact same way.

arrow. So do you have a python code that I can scan in order? a sequential code where I can specify the scan interval.
legendary
Activity: 1988
Merit: 1077
Honey badger just does not care
Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?


Why would you want the binary value over hex?

I think the scanning process will be faster.

No it won't, python interpreter represents these numbers in the exact same way.
newbie
Activity: 10
Merit: 0
Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?


Why would you want the binary value over hex?

I think the scanning process will be faster.
newbie
Activity: 7
Merit: 1
Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?


Why would you want the binary value over hex?
newbie
Activity: 10
Merit: 0
Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?
newbie
Activity: 7
Merit: 1
A revised effort to consolidate our compute power by means of a pool:

https://discord.gg/YeUYPDUmVV
newbie
Activity: 3
Merit: 0
Hi,
Where can I find python software to create private key with publickey?
It may be in other software.

thank you.



I wonder if there is bruteforce software available for python by giving short distances (hex or binnary).


yes  this fast one https://github.com/albertobsd/keyhunt#readme
newbie
Activity: 10
Merit: 0
Hi,
Where can I find python software to create private key with publickey?
It may be in other software.

thank you.



I wonder if there is bruteforce software available for python by giving short distances (hex or binnary).
member
Activity: 406
Merit: 47
I think all method with "random" any technic or idea all it never works.
but method calculate or algorithm may be can work possible

jr. member
Activity: 67
Merit: 1
Someone has to break 64 puzzles because the creator sent and published from 65 up publick keys which seems a little strange to me that up to 63 it could creater data after 1 bit and from 64 can be fully full protect 64 hexadecimal address
Simply put, the puzzle could have been created to determine the maximum possible protection against the Kangaroo guess method
therefore I will probably look for a 120 bit address, because I am sure that there should be 100% in the range of 120 bits
therefore, someone should finally 64 puzzle complete the  of the puzzle to show in doubt that the whole pyramid is correct and each address up increases by one bit.
full member
Activity: 1316
Merit: 126
I don't know why but I'm smelling a big scam. Because a newbie that offer more than 12 000€ to solve a following of numbers this is strange...
Thats what i am thinking too. I smells something's fishy..Well, lets just ignore this if we dont know how it works.. Grin Its better to be safe than sorry.
newbie
Activity: 1
Merit: 0
this little update will loop infinite to solution and less output without tqdm

Code:
import time
import random
import bit
from bit import *
from time import sleep

print('',time.ctime())
print('\n ============== ================= ==RANDOM HUNTER== ================= ==============\n\n')

i = 1000000

keys=0
while True:
    t = int(time.time())
    while keys<=i:
        #a1 = random.randrange(0x20000000000000000,0x3ffffffffffffffff)
        ## "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"
        
        a1 = random.randrange(0x8000000000000000,0xffffffffffffffff)
        ## "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN"
        
        keys+=1
        key = Key.from_int(a1)
        y1 = key.address
        #print('y1=',y1,' hex=',hex(a1))
        #print('a1=',a1)
        #filetest=open("16j.Target.test.txt","a")
        #filetest.write('\n '+str(hex(a1))+' | a1='+ str(a1) + ' | addr=' + str(y1) + '\n')
        #filetest.close()
        if y1.startswith('16jY7q'):
            print('' + hex(a1) + ' | ' + y1 + ' \n')
            file=open("16j.Target.Info.partial.txt","a")
            file.write('\n '+str(hex(a1))+' | a1='+ str(a1) + ' | addr=' + str(y1) + '\n')
            file.close()
        if y1 == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
            print('Target found!!' + hex(line) + ' | ' + y1 + '\n')
            file=open("16j.Target.Info.txt","a")
            file.write('\n '+str(hex(a1))+' | a1='+ str(a1) + ' | addr=' + str(y1) + '\n')
            file.close()
            wait = input("Press Enter to Exit.")
            sleep(8640000)
            exit()

        #if keys == i:
        #    took = int(time.time() - t)
        #    pps = int(keys / took)
        #    #print('',i,' keys took',took,'seconds @ ',pps,' pps')
        #    keys = 0
        #    t = int(time.time())


hooked my 3080ti up to ttdsales.com/64bit and time to solution went down from 85 to 39 years now in last 2 days.

come and crack #64!

download bitcrack64, search cudart64_101.dll in your windows folder and copy it to bitcrack.
move ttdclient to bitcrack folder


settings.ini
Code:
devjorge
cu
-b 80 -t 640 -p 1024


8

-b 80 -t 640 -p 1024

settings for geforce rtx 3080ti with good cooling and powerlimit @ 113% mem +1000 core +100 = 2050 MKey/s @ 400-450W (Eff: 4,55 Mkey/W)

without overclocking and powerlimit 80% = 1600-1700 Mkey/s @ 300-325W (Eff: 5,2 Mkey/W)

Jump to: