Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Feron]

to be honest, I don't use these codes myself  
simply, if someone has the upper hand over others, then the code would not publish the logically they will always keep it for themselves
although I'm of the opinion that luck there plays a big role or that start range you can type as in the lottery
or let it go sequentially and wait 300 years
someone will write the initial range and empty the address now
those 300 years it's just figurative it can break now or never
+ you are not sure yet that the address is in the 16 hexadecimal range, what if this address was generated incorrectly and the creator did not check all the addresses
maybe I'm wrong, so all the first addresses have the right range, but you never know

[enfarktus]

Hi all this easy matematic 1+1 code
code:
from bit import Key
import random
for x in range(1000000000):
 xx = random.randint(4611686018427387904,9223372036854775808)
 cc = xx+xx
 k1 = Key.from_int(int(cc))
 if (str(k1)).startswith("<PrivateKey: 16jY"):
  print(cc,xx,k1,x)
 if (str(k1)) == "<PrivateKey: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN>":
  f=open("win.txt","a")
  f.write(str(cc)+(str(k1))+"\n")
  f.close()
the simpler the faster
code compute 4611686018427387904 to 9223372036854775808 take one number maximum 9223372036854775808 keyspace and doubles it him final decimal is private key little reduces the key space

Nice work. Thank  you for share.

[Feron]

Hi all this is 64 public key hunters work correct
She small chance to hit the 64 public key, but that's all for fun
it doesn't use a bitcoin library, so the running code quickly converts to c+ and runs at full power
now it's faster that one print was holding it back
it generates a public key not a public address it's even worse than brute force because you have to break the whole 64 hexadecimal
and generate equivalent hash160 public address easy peasy
if I added base58 there I could convert hash 160 to bitcoin addresses but that would slow down the speed

Code:

import hashlib
import codecs
import random
for x in range(1000000000):
 x0 = ("00","01","02","03","04","05","06","07","08","09","0a","0b","0c","0d","0e","0f","10","11","12","13","14","15","16","17","18","19","1a","1b","1c","1d","1e","1f",
       "20","21","22","23","24","25","26","27","28","29","2a","2b","2c","2d","2e","2f","30","31","32","33","34","35","36","37","38","39","3a","3b","3c","3d","3e","3f",
       "40","41","42","43","44","45","46","47","48","49","4a","4b","4c","4d","4e","4f","50","51","52","53","54","55","56","57","58","59","5a","5b","5c","5d","5e","5f",
       "60","61","62","63","64","65","66","67","68","69","6a","6b","6c","6d","6e","6f","70","71","72","73","74","75","76","77","78","79","7a","7b","7c","7d","7e","7f",
       "80","81","82","83","84","85","86","87","88","89","8a","8b","8c","8d","8e","8f","90","91","92","93","94","95","96","97","98","99","9a","9b","9c","9d","9e","9f",
       "a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","aa","ab","ac","ad","ae","af","b0","b1","b2","b3","b4","b5","b6","b7","b8","b9","ba","bb","bc","bd","be","bf",
       "c0","c1","c2","c3","c4","c5","c6","c7","c8","c9","ca","cb","cc","cd","ce","cf","d0","d1","d2","d3","d4","d5","d6","d7","d8","d9","da","db","dc","dd","de","df",
       "e0","e1","e2","e3","e4","e5","e6","e7","e8","e9","ea","eb","ec","ed","ee","ef","f0","f1","f2","f3","f4","f5","f6","f7","f8","f9","fa","fb","fc","fd","fe","ff")
 z0 = random.choices(x0,k=8)
 z1 = random.choices(x0,k=8)
 z2 = random.choices(x0,k=8)
 z3 = random.choices(x0,k=8)
 c0 = ''.join(z0)
 c1 = ''.join(z1)
 c2 = ''.join(z2)
 c3 = ''.join(z3)
 xx = "02"+c0+c1+c2+c3
 cc = "03"+c0+c1+c2+c3
 publickey02 = codecs.decode(xx,"hex")
 publickey03 = codecs.decode(cc,"hex")
 s2 = hashlib.new('sha256', publickey02).digest()
 s3 = hashlib.new('sha256', publickey03).digest()
 r2 = hashlib.new('ripemd160', s2).digest()
 r3 = hashlib.new('ripemd160', s3).digest()
 z2 = codecs.encode(r2, 'hex').decode("utf-8")
 z3 = codecs.encode(r3, 'hex').decode("utf-8")
 if (str(z2)).endswith("248a4"):
  pass
 if (str(z3)).endswith("248a4"):
  print(z2,z3,xx,cc,x)
 if (str(z2)) == "3ee4133d991f52fdf6a25c9834e0745ac74248a4":
  f=open("win2.txt","a")
  f.write(str(z2)+"-"+(xx)+"\n")
  f.close()
 if (str(z3)) == "3ee4133d991f52fdf6a25c9834e0745ac74248a4":
  f=open("win3.txt","a")
  f.write(str(z3)+"-"+(cc)+"\n")
  f.close()

[zahid888]

Code:

import hashlib
import codecs
import random

list = ["3ee4133d991f52fdf6a25c9834e0745ac74248a4","20d45a6a762535700ce9e0b216e31994335db8a5","739437bb3dd6d1983e66629c5f08c70e52769371","e0b8a2baee1b77fc703455f39d51477451fc8cfc","61eb8a50c86b0584bb727dd65bed8d2400d6d5aa","f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8","bf7413e8df4e7a34ce9dc13e2f2648783ec54adb","105b7f253f0ebd7843adaebbd805c944bfb863e4","9f1adb20baeacc38b3f49f3df6906a0e48f2df3d","86f9fea5cdecf033161dd2f8f8560768ae0a6d14","783c138ac81f6a52398564bb17455576e8525b29","35003c3ef8759c92092f8488fca59a042859018c","67671d5490c272e3ab7ddd34030d587738df33da","351e605fac813965951ba433b7c2956bf8ad95ce","20d28d4e87543947c7e4913bcdceaa16e2f8f061","24cef184714bbd030833904f5265c9c3e12a95a2","7c99ce73e19f9fbfcce4825ae88261e2b0b0b040"]

for x in range(1000000000):
 x0 = ("00","01","02","03","04","05","06","07","08","09","0a","0b","0c","0d","0e","0f","10","11","12","13","14","15","16","17","18","19","1a","1b","1c","1d","1e","1f",
       "20","21","22","23","24","25","26","27","28","29","2a","2b","2c","2d","2e","2f","30","31","32","33","34","35","36","37","38","39","3a","3b","3c","3d","3e","3f",
       "40","41","42","43","44","45","46","47","48","49","4a","4b","4c","4d","4e","4f","50","51","52","53","54","55","56","57","58","59","5a","5b","5c","5d","5e","5f",
       "60","61","62","63","64","65","66","67","68","69","6a","6b","6c","6d","6e","6f","70","71","72","73","74","75","76","77","78","79","7a","7b","7c","7d","7e","7f",
       "80","81","82","83","84","85","86","87","88","89","8a","8b","8c","8d","8e","8f","90","91","92","93","94","95","96","97","98","99","9a","9b","9c","9d","9e","9f",
       "a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","aa","ab","ac","ad","ae","af","b0","b1","b2","b3","b4","b5","b6","b7","b8","b9","ba","bb","bc","bd","be","bf",
       "c0","c1","c2","c3","c4","c5","c6","c7","c8","c9","ca","cb","cc","cd","ce","cf","d0","d1","d2","d3","d4","d5","d6","d7","d8","d9","da","db","dc","dd","de","df",
       "e0","e1","e2","e3","e4","e5","e6","e7","e8","e9","ea","eb","ec","ed","ee","ef","f0","f1","f2","f3","f4","f5","f6","f7","f8","f9","fa","fb","fc","fd","fe","ff")
 z0 = random.choices(x0,k=8)
 z1 = random.choices(x0,k=8)
 z2 = random.choices(x0,k=8)
 z3 = random.choices(x0,k=8)
 c0 = ''.join(z0)
 c1 = ''.join(z1)
 c2 = ''.join(z2)
 c3 = ''.join(z3)
 xx = "02"+c0+c1+c2+c3
 cc = "03"+c0+c1+c2+c3
 publickey02 = codecs.decode(xx,"hex")
 publickey03 = codecs.decode(cc,"hex")
 s2 = hashlib.new('sha256', publickey02).digest()
 s3 = hashlib.new('sha256', publickey03).digest()
 r2 = hashlib.new('ripemd160', s2).digest()
 r3 = hashlib.new('ripemd160', s3).digest()
 z2 = codecs.encode(r2, 'hex').decode("utf-8")
 z3 = codecs.encode(r3, 'hex').decode("utf-8")
 if (str(z2)).endswith("248a4"):
  pass
 if (str(z3)).endswith("248a4"):
  print(z2,z3,xx,cc,x)
 if (str(z2)) in list:
  f=open("win.txt","a")
  f.write(str(z2)+"-"+(xx)+"\n")
  f.close()
 if (str(z3)) in list:
  f=open("win.txt","a")
  f.write(str(z3)+"-"+(cc)+"\n")
  f.close()

[Jolly Jocker]

Code:

# with status bar

import tqdm
import hashlib
import codecs
import random
from tqdm import tqdm

list = ["3ee4133d991f52fdf6a25c9834e0745ac74248a4","20d45a6a762535700ce9e0b216e31994335db8a5","739437bb3dd6d1983e66629c5f08c70e52769371","e0b8a2baee1b77fc703455f39d51477451fc8cfc","61eb8a50c86b0584bb727dd65bed8d2400d6d5aa","f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8","bf7413e8df4e7a34ce9dc13e2f2648783ec54adb","105b7f253f0ebd7843adaebbd805c944bfb863e4","9f1adb20baeacc38b3f49f3df6906a0e48f2df3d","86f9fea5cdecf033161dd2f8f8560768ae0a6d14","783c138ac81f6a52398564bb17455576e8525b29","35003c3ef8759c92092f8488fca59a042859018c","67671d5490c272e3ab7ddd34030d587738df33da","351e605fac813965951ba433b7c2956bf8ad95ce","20d28d4e87543947c7e4913bcdceaa16e2f8f061","24cef184714bbd030833904f5265c9c3e12a95a2","7c99ce73e19f9fbfcce4825ae88261e2b0b0b040"]

for x in tqdm(range(1000000000)):
 x0 = ("00","01","02","03","04","05","06","07","08","09","0a","0b","0c","0d","0e","0f","10","11","12","13","14","15","16","17","18","19","1a","1b","1c","1d","1e","1f",
       "20","21","22","23","24","25","26","27","28","29","2a","2b","2c","2d","2e","2f","30","31","32","33","34","35","36","37","38","39","3a","3b","3c","3d","3e","3f",
       "40","41","42","43","44","45","46","47","48","49","4a","4b","4c","4d","4e","4f","50","51","52","53","54","55","56","57","58","59","5a","5b","5c","5d","5e","5f",
       "60","61","62","63","64","65","66","67","68","69","6a","6b","6c","6d","6e","6f","70","71","72","73","74","75","76","77","78","79","7a","7b","7c","7d","7e","7f",
       "80","81","82","83","84","85","86","87","88","89","8a","8b","8c","8d","8e","8f","90","91","92","93","94","95","96","97","98","99","9a","9b","9c","9d","9e","9f",
       "a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","aa","ab","ac","ad","ae","af","b0","b1","b2","b3","b4","b5","b6","b7","b8","b9","ba","bb","bc","bd","be","bf",
       "c0","c1","c2","c3","c4","c5","c6","c7","c8","c9","ca","cb","cc","cd","ce","cf","d0","d1","d2","d3","d4","d5","d6","d7","d8","d9","da","db","dc","dd","de","df",
       "e0","e1","e2","e3","e4","e5","e6","e7","e8","e9","ea","eb","ec","ed","ee","ef","f0","f1","f2","f3","f4","f5","f6","f7","f8","f9","fa","fb","fc","fd","fe","ff")
 z0 = random.choices(x0,k=8)
 z1 = random.choices(x0,k=8)
 z2 = random.choices(x0,k=8)
 z3 = random.choices(x0,k=8)
 c0 = ''.join(z0)
 c1 = ''.join(z1)
 c2 = ''.join(z2)
 c3 = ''.join(z3)
 xx = "02"+c0+c1+c2+c3
 cc = "03"+c0+c1+c2+c3
 publickey02 = codecs.decode(xx,"hex")
 publickey03 = codecs.decode(cc,"hex")
 s2 = hashlib.new('sha256', publickey02).digest()
 s3 = hashlib.new('sha256', publickey03).digest()
 r2 = hashlib.new('ripemd160', s2).digest()
 r3 = hashlib.new('ripemd160', s3).digest()
 z2 = codecs.encode(r2, 'hex').decode("utf-8")
 z3 = codecs.encode(r3, 'hex').decode("utf-8")
 if (str(z2)).endswith("248a4"):
  pass
 if (str(z3)).endswith("248a4"):
  print(z2,z3,xx,cc,x)
 if (str(z2)) in list:
  f=open("win.txt","a")
  f.write(str(z2)+"-"+(xx)+"\n")
  f.close()
 if (str(z3)) in list:
  f=open("win.txt","a")
  f.write(str(z3)+"-"+(cc)+"\n")
  f.close() 

[PrivatePerson]

what the hell are you posting?

[Andzhig]

Hi there Andzhig, you have a complete package of these things you are programming to start searching somehow.
thanks man,

not yet, there is too much to think about  

***

It can be stuck in this shit for the rest of your life.

All this madness is described by the formula Ralph Hartley (I = K log2(N)) or easier log2(x)=

this means that for puzzle 20, 2^20 looks like that  log2(2^20) = 20  

in other words in 2^20 = 1048576 will fall out with equal probability 20 bit information from 00000000000000000000 to 11111111111111111111

can take a long string 1048576 random bit or 1048576 segments of 20 bits if you take a long string, it seems to fall out more often, since information is not lost when trimmed

although it is possible 1048576/20 = 52428,8 or pz64 9223372036854775808/64 144115188075855872 segments of 64 bits...

you can play with these

import random

list2 = ["1HsMJxNiV7TLxmoF6uJNkydxPFDog4NQum"] # pz 20 > dec 863317 bit 11010010110001010101

count0 = 0

pzbit = "11010010110001010101"

for X in range(100): # log2(x)=20 2^20 = 1048576, 1048576/20 = 52428,8
        
    count0 += 1

    random.seed()

    Nn = "0","1"

    RRR = [] #func()

    for RR in range(52428): # "bit" set log2(x)=20 2^20 = 1048576, 1048576/20 = 52428,8
        DDD = random.choice(Nn)
        RRR.append(DDD)

    d = ''.join(RRR)
    #print(d,count0)

    if pzbit in d:
        print("step",count0,d)
        break
    
print("pz end")
input() #"pause"

there is a so-called division method, but no one will tell us the desired number in which part after division, but simply iterating and 64 bit steps come out

How many questions do you need to ask to find the intended number from 1 to 100. Let's say the hidden number is 27. Dialogue option:

Over 50? No.
Over 25? Yes.
Over 38? No.
Less than 32? Yes.
Under 29? Yes.
Under 27? No.
Is it number 28? No.

If the number is not 28 and not less than 27, then it is clearly 27. To guess the number from 1 to 100 using the “halving” method, we needed 7 questions.

The amount of information embedded in the answer "yes" / "no", if these answers are equally likely, is equal to one bit (indeed, because a bit has two states: 1 or 0). So, to guess a number from 1 to 100, we needed seven bits (seven yes/no answers).

and collisions turn out to be like "frozen" probabilities

1048576 steps endless seed dropped in one place + 1048576 seed steps dropped out elsewhere and so on until all the places are moved and the newly mixed ones fall out the same as searching in a "long string 1048576 random bit" , if you imagine that 1048576 step collision steps gives 1 needed 20 bits, 1048576×1048576 = 1099511627776 and 1099511627776/1048576 = 1048576 collision. it means there will be such lines where the required 20 bits will be at 1 step somewhere at 2, 3, etc. but they are all mixed. (now someone smart should come and explain everything). so we have this 1099511627776 where half of "from 1 to 1048576/2=524288" 20 bit will be on the first step on the second on the third and so on from 1048576 (the other half is closer to the other end 524288-1048576), if we step through 1 step then we lose - 1 for each (is it necessary or is it 1099511627776 divided by 2 or 1048576/2, 524288, 524288×524288 = 274877906944) after 3 steps... in general, we need to shorten the general steps and at the same time get the side that will be closer either to the beginning or to the end of the 1048576 frozen "collisions of probability sets" to make the probability work faster  

 if you understand how it works, you can crack any passwords and no hash functions will help even if you check them a million (maybe )

someone finds connections with Blaise Pascal triangle, maybe Frank Ramsey ideas... and other alien language.

collisions by themselves do not increase the likelihood

40116600 28!/14!/14!  
1048576 2^20 (40116600 ~ 2^25)/(2^20) = 32
38,25817108154296875 collision

1/2^20  0,00000095367431640625
1-((1-0,00000095367431640625)^1000000) = 0,61467755323380387101550329885023410368873814360323

38/2^25,257696002689131014443589368702137499212705986576
1-((1-0,00000094723879890120299327460452780145874775030785260932)^1000000)  = 0,612189805130850082275327609457471664463427528904805418181047671964854503332114

unless of course you increase the chance of the desired segment appearing in the right place because 38/2^25 without rounding increase the chance (actually not) we are back to the beginning of the post...

***
and a little as the guru of observations himself wrote https://bitcointalk.org/index.php?topic=571.msg5754#msg5754 "analytical attack"

from the hash 3ee4133d991f52fdf6a25c9834e0745ac74248a4 can get dec 359043673790534646037006540730459475416853924004 bin 1111101110010000010011001111011001100100011111010100101111110111110110101000100 1011100100110000011010011100000011101000101101011000111010000100100100010100100

bin 158 len, 0 > 80, 1 > 78 158!/80!/78! = 22866556412845927056888423836329770613886986170 all perm, pz perm index 22537107205443855325270509529770241715849156734

if not filtered by length and number of bits everything happens according to formula Ralph Hartley log2(x)=

9223372036855015810 1000000000000000000000000000000000000000000000111010100110000010 9  240003   1111101110010000010011000111010111000111111100011011011001110110001101001010110 1001001101110000001111010101010001001110000110101101101111110011101111101000111 0 7180873256989556446556621835558134870175050461                  
9223372036856173927 1000000000000000000000000000000000000000000101010101010101100111 13 1398120  1111101110010000010011000011100101010001011111001101111110111110000100101000000 0100110110110101001010111111100001100001110110001100100100001111100011000011111 0 718087315411756854546296510280667756869467475006
9223372036856212177 1000000000000000000000000000000000000000000101011110101011010001 13 1436370  1111101110010000010000111101101001111001110100100000011101111001011010100110010 0111111111011100101001011111110100101001010100101010001000101011111011010000011 359043475413003167110670037757778762634123146883
9223372036856890237 1000000000000000000000000000000000000000001000000100001101111101 11 2114430  1111101110010000010001010101001101011110100011110110110100000111000011011111001 01100000100001000000001111010101110000100010110101000011101101110010010101000 89760876868889376100370289127772432756922311848
9223372036857266442 1000000000000000000000000000000000000000001001100000000100001010 7  2490635  1111101110010000010010100111011000111010111111110111011001010000001000111101010 01011100001101110111000100000100110100000110011001111010011100001011011011110 89760904832892002273251104243477641619552736990
9223372036857335565 1000000000000000000000000000000000000000001001110000111100001101 12 2559758  1111101110010000010011011000001100000110011010111001000000010111110001100101011 0001011000111010100011011101100000100110101110010011000100000001011010111010101 1 718087371508456404393008177736344416239946394539
9223372036857594444 1000000000000000000000000000000000000000001010110000001001001100 9  2818637  1111101110010000010001001111100010111010010111111001010100110100011011001001110 0001101011000000011011110000001111001010101001111010111001110000111101010101011 11 1436173999058575188054474948077251433121726982831
9223372036857826935 1000000000000000000000000000000000000000001011101000111001110111 15 3051128  1111101110010000010011110101010110100010000110000101001001000110110111100100001 1000110001000101111100101111111011010110010011011111100001001100111100110010010 1 718087450897711573434130801635077538092006830885
9223372036858012530 1000000000000000000000000000000000000000001100010110001101110010 12 3236723  1111101110010000010001001110111101101110001101111111000110101001101011100011110 0011011011000100111110101000010001100111010100101001110001110101100011010011011 1 718086997947403370741861272986691544035227962679
9223372036859320480 1000000000000000000000000000000000000000010001010101100010100000 9  4544673  1111101110010000010000001111101001000101110111111111110010100110100001110110010 0110010000011000110101001110111101001010011001111111100110011111111111001001110 0 718086825567571615737455690104698414644087225500
9223372036860047270 1000000000000000000000000000000000000000010100000110111110100110 13 5271463  1111101110010000010001110000001110000000101111010001100010001101000100110010010 0010000001001111000001011011110110000101010100110101111011011011010001101100111 01 1436174176949643411576885315413363742972568833437
9223372036860070794 1000000000000000000000000000000000000000010100001100101110001010 11 5294987  1111101110010000010011100110010101000011001010001010010000010111011110101001100 1000011011100110100101010000011010111010101001001100110100110000011100000000000 359043705000365790599054799634814692545330165760
9223372036860902238 1000000000000000000000000000000000000000010111010111101101011110 17 6126431  1111101110010000010001110101101011001010111111111101110110000001100101101000000 1001110110111100011110010011010101010010011110100001000000010111001010111111010 1 718087103326459445851943810622436577706585304053
9223372036861245274 1000000000000000000000000000000000000000011000101011011101011010 14 6469467  1111101110010000010010001101110100111111010101111100011111011010010100010000110 1111010000101101111010101111001011101000100010001001010011011011101000011011 44880448067392482926173035093376359281690786331
9223372036861628193 1000000000000000000000000000000000000000011010001000111100100001 11 6852386  1111101110010000010011110011110100111110011011110000110101111100111101001010100 001000011001011100011110101110001111100010111001100001011101011110000111100101 179521861687021734476616064965674768707389612517
9223372036861892836 1000000000000000000000000000000000000000011011001001100011100100 12 7117029  1111101110010000010001100011011100110100101110111001101001100110101000011100000 011101100100110100100010110101011111011000011001111011000111011010001111100000 179521763428876435137444313193721929344487367648
9223372036861947467 1000000000000000000000000000000000000000011011010110111001001011 15 7171660  1111101110010000010000011001100111110100111110010000010011110100010110101110110 1000101001000101111111010100011011001110100010110111000010111101011011000111000 0 718086852736392223506631086848100616858893118576
9223372036862265987 1000000000000000000000000000000000000000011100100100101010000011 11 7490180  1111101110010000010001001011110100111000110111011111001111110110110110010100101 011111110110111101101001100111100010100000000001101100100110000111101000110011 179521747351221506452705485581043535576301074995
9223372036862331902 1000000000000000000000000000000000000000011100110100101111111110 17 7556095  1111101110010000010011001101001001100101011000100010100001011000111110111011010 1101100000111101110101111000000011000110011111110010011101011001110001001000101 01 1436174682913161688503498477533112283699141118229
9223372036862506554 1000000000000000000000000000000000000000011101011111011000111010 16 7730747  1111101110010000010001000110100101001111110010010100101111011100111100011111011 1000010000101011000110000000011010111110101011101001010010011010000000100011000 01 1436173950256518218731585303577429277482264298593
9223372036862531880 1000000000000000000000000000000000000000011101100101100100101000 12 7756073  1111101110010000010000100000111010111100110110001100011110010010111111011111010 0110100111001010010011100001010110100100001100110001010101011010010010010010010 01 1436173745211217210558743667607337568893540799049
9223372036862744754 1000000000000000000000000000000000000000011110011001100010110010 13 7968947  1111101110010000010011000101100001110010011111011110110111001010011001011100100 00010011111111100101000111000100111000101111111001111111110100111010111101111 89760915088508567795605768827019024851757856239
9223372036863733714 1000000000000000000000000000000000000000100010001010111111010010 13 8957907  1111101110010000010011001000011010101001001001011100010010010111111101000100111 1101111111011001110001011000000001010001001011000101010111010010000111100101001 1 718087328570887872581080841805785257502617771603
9223372036863737516 1000000000000000000000000000000000000000100010001011111010101100 13 8961709  1111101110010000010010001111011000101111000001000101100011100100110001110000101 0001001000011110110111000110110110101000011111000000110111111011001011101110001 359043586660479441892627990740535085044334434161
9223372036865317982 1000000000000000000000000000000000000000101000001101110001011110 13 10542175 1111101110010000010010011000100001111011101100110100111110100111101100101010000 1110111110000100001111101000110111010000001001100110001011110111111011001100101 0 718087198212536565138252364124209929591732038858

at steps  (log2(x)=20 2^20 = 1048576) finds the first 20 bits of the hash, although he is here generously on 10542175 25 by 20 bits poured (should be 10542175 /1048576 = ~10, "frozen probability" ).  

when filtering, everything is transformed somewhere

9223372036885616568  1000000000000000000000000000000000000001110101101001011110111000 16 22537103149060538292017163274311134567780254106 30840761  1111101110010000010010100010110000100011000101110111000110110111110101011000001 1001001110101101111111010111110000000110101001101011110001000011000010011000010 359043613028399983562945167723792076799337399490
9223372037029689218  1000000000000000000000000000000000001010011011001111011110000010 16 22537101874911141106658805675039550989222719457 174913411 1111101110010000010010010100111001011110010010011100100110001010111000100010001 0000011011010001101111011001111100000100101001101011101001111101110110000000111 359043594162400081422090571493616731684910066695
9223372037031770991  1000000000000000000000000000000000001010100011001011101101101111 18 22537107574203928862325124755510621787207775646 176995184 1111101110010000010011010011011010110000001010010101100100001100011011100010011 0001000001101000111001001110101111111011101101011100100111010100001110001010011 359043679260198876783299078950464798741917998163
9223372037058474564  1000000000000000000000000000000000001100001001000011001001000100 10 22537103592731005799528051981089682732148344971 203698757 1111101110010000010010100111011111000001000111111000111010001010110011010110011 0000010101011000011110001001101110101011100000100110101010101100111001110000001 359043619461209399913287633908985905780119466881

only 4 per 200 million steps (but could be 203698757/1048576 = ~194)

are the permutation indices

22537107205443855325270509529770241715849156734 pz64
22537103149060538292017163274311134567780254106
22537101874911141106658805675039550989222719457
22537107574203928862325124755510621787207775646
22537103592731005799528051981089682732148344971

does it make sense to do something with this in search of "analytical attack"

divide up to 5 signed and collect statistics or something else

16169,5814232638689562143432562009521116008707624031369835027035608950872669432 pz
16153,5533775264321952269735570804750668963341349990553644343264675297401430888
16181,4699735846556996755461776490184756227607973040633725147294856365627617568
16185,1503837668620918566318996649467160755508899938504822869445787677713040070
16179,6817735469296456613873633125445961914982781727372100885964864332408993487
16153,6970565574610790826901021689464637807015377239042354189722685675176350481
16190,6635088900851730204004885232081983178955608845804638586660470304890338518
16157,8797916296129003863290552042679182640000395504078556841408290366099696895
16175,7751788632852421380331566366568529725406711580288457971208637282374131337
16167,2147331482160603431952405779044274472086659418012334815885384046033101030
16140,0690439666614661705398239915453571632329370682713054379439195260580545749
16158,4759908930506778003347436100751039440563712880665211532911595075679978952
16157,8061286871790467784305109191598032784456191195778051755983314706401974056
16151,4172150387504450853711611863511146513260901870546579554804901185534937987
16182,0031786348789876742354647759795337633119335192744071229767381262997539896
16155,7050285239593882946006590997299172487673304627256330600015171172885379131

in any case, it is difficult to select a step to find the right one...

if there are crazy ones who crank the minced meat back through the meat grinder (sha256,ripmd160). or calculate the most frequent bit positions in bin 2^64

this means calculating for each set bit 2^64 their most frequent positions (normal idea for a collision attack  )

     1 count, 0 count
64!/32!/32!    1832624140942590534
64!/31!/32!    1777090076065542336
64!/53!/11!    743595781824

and the most average that can work to get

3ee4133d991f52fdf6a25c9834e0745ac74248a4
359043673790534646037006540730459475416853924004
1111101110010000010011001111011001100100011111010100101111110111110110101000100 1011100100110000011010011100000011101000101101011000111010000100100100010100100

which will also need to be calculated in order to understand how much they can take on themselves from those combinations... One Flew Over the Cuckoo's Nest...

[dextronomous]

so wow puzzle 20 works,
but you have anything else for the 64th puzzle.
thanks

[Jolly Jocker]

Code:

import bit
import tqdm
import time
import random
from bit import *
from tqdm import tqdm
from time import sleep
t = time.ctime()
print('',t)
sleep(1)
print('\n ================= ================= ================= ================= =================')
print('\n\n RANDOM BITCOIN PREDATOR \n #64: 8000000000000000...ffffffffffffffff\n\n')
f=[]
i=0
a=4000000
print('\n Generate',str(a),'random Keys and sort....')
while i < a:
    f.clear()
    print('\n\n WAIT! ', end='\r')
    sleep(1)
    start = time.time()
    f = random.sample(range(9223372036854775808,18446744073709551615), a)
    f.sort()
    end = time.time()
    print('',str(a),'Keys DONE !!','{:5.3f}s'.format(end-start),'\n')
    sleep(1)
    print (' start scanning... ', end='\r')
    sleep(2)
    for line in tqdm(f):
        line!='\n'
        pass
        key = Key.from_int(line)
        addr = key.address

        if addr.startswith('16jY7') or addr.endswith('jyXQN'):
            print('\n\n',hex(line),'|', addr)
            sleep(1)
            print('\n continue...\n')
            sleep(1)

        if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
            print('\n\n Target found!!' + hex(line) + ' \n ' + addr,'\n')
            file=open(u"16j.Target.Info.txt","a")
            file.write('\n ' + hex(line) + ' | ' + addr)
            file.close()
            sleep(2)
            wait = input("Press Enter to Exit.")
            sleep(1)
            exit()

[Jolly Jocker]

# Python 3.9.7
view, way of working.. happy hunting!  BTC  

Code:

 Sat Jan 29 13:32:58 2022

 ================= ================= ================= ================= =================


 RANDOM BITCOIN PREDATOR
 #64: 8000000000000000...ffffffffffffffff



 Generate 4000000 random Keys and sort....


 4000000 Keys DONE !! 6.426s

 37%|█████████████████?                               | 1462908/4000000 [02:09<03:26, 12289.05it/s]

 0xaed60f700efb2d13 | 16jY79d6zdGihLwnJ6to9XsUpBGhx7DJzh

 continue...

100%|█████████████████████████████████████████████████| 4000000/4000000 [05:39<00:00, 11784.16it/s]


 4000000 Keys DONE !! 6.582s

100%|█████████████████████████████████████████████████| 4000000/4000000 [05:27<00:00, 12211.18it/s]


 4000000 Keys DONE !! 6.422s

 24%|███████████?                                      | 957290/4000000 [01:20<04:05, 12390.64it/s]

 0x9ea1c04c218e3225 | 16jY7Bw3QAKqEUaipMpoJuo8Bk6yYQhgPA

 continue...

100%|█████████████████████████████████████████████████| 4000000/4000000 [05:29<00:00, 12132.94it/s]


 4000000 Keys DONE !! 6.578s

 36%|█████████████████?                               | 1457119/4000000 [01:57<03:20, 12651.31it/s]

 0xaeace2bf4b35cdf3 | 16jY7TpoxQJurJUD4JjNNVYDqR1mbf9JUn

 continue...

100%|█████████████████████████████████████████████████| 4000000/4000000 [05:50<00:00, 11414.73it/s]


 WAIT!

[solvepuzzle]

Code:

import bit
import tqdm
import time
import random
from bit import *
from tqdm import tqdm
from time import sleep
t = time.ctime()
print('',t)
sleep(1)
print('\n ================= ================= ================= ================= =================')
print('\n\n RANDOM BITCOIN PREDATOR \n #64: 8000000000000000...ffffffffffffffff\n\n')
f=[]
i=0
a=4000000
print('\n Generate',str(a),'random Keys and sort....')
while i < a:
    f.clear()
    print('\n\n WAIT! ', end='\r')
    sleep(1)
    start = time.time()
    f = random.sample(range(9223372036854775808,18446744073709551615), a)
    f.sort()
    end = time.time()
    print('',str(a),'Keys DONE !!','{:5.3f}s'.format(end-start),'\n')
    sleep(1)
    print (' start scanning... ', end='\r')
    sleep(2)
    for line in tqdm(f):
        line!='\n'
        pass
        key = Key.from_int(line)
        addr = key.address

        if addr.startswith('16jY7') or addr.endswith('jyXQN'):
            print('\n\n',hex(line),'|', addr)
            sleep(1)
            print('\n continue...\n')
            sleep(1)

        if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
            print('\n\n Target found!!' + hex(line) + ' \n ' + addr,'\n')
            file=open(u"16j.Target.Info.txt","a")
            file.write('\n ' + hex(line) + ' | ' + addr)
            file.close()
            sleep(2)
            wait = input("Press Enter to Exit.")
            sleep(1)
            exit()

Hello thanks for the code. I tried to modify it for puzzle 66. This error pops up


RANDOM BITCOIN PREDATOR
 #66: 20000000000000000...3ffffffffffffffff



 Generate 4000000 random Keys and sort....


Traceback (most recent call last):
  File "main.py", line 22, in <module>
    f = random.sample(range(36893488147419103232,73786976294838206463), a)
  File "/usr/lib/python3.8/random.py", line 361, in sample
    n = len(population)
OverflowError: Python int too large to convert to C ssize_t


Any ideas how to modify it to work with other puzzles

[Jolly Jocker]

Hi Dude, I am aware of this problem and it has the following cause..

The range is limited by random (9223372036854775807).. so 66 bit can only be partially scanned...
In this case from 30000000000000000 - 37ffffffffffffffff, then 37ffffffffffffffff + 9223372036854775807 (7fffffffffffffff), etc...

this is the maximum of random Range..

Code:

print('\n > The range is limited by random (9223372036854775807).. so 66 bit can only be partially scanned! <')
print('\n > In this case from 30000000000000000 - 37ffffffffffffffff ! < \n\n')
import gc
import tqdm
import time
import random
import bit
from bit import *
from time import sleep
t = time.ctime()
print('',t)
list=[]
i = 1000000
while True:
    start = time.time()
    print('\n\n generate',str(i),'Keys and sort..... ')
    del list
    gc.collect(generation=2)
    sleep(1)
    list = random.sample(range(55340232221128654848,64563604257983430655), i)
    list.sort()
    n = len(list)  
    ende = time.time()
    if n == i:
        print ('\n',n,'Keys DONE !!','{:5.3f}s'.format(ende-start))
        sleep(1)
        print ('\n Start Scanning..!! \n')
        sleep(2)
        for line in tqdm.tqdm(list):
            line != "\n"
            key1 = Key.from_int(line)
            y1 = key1.address
            
            if y1.startswith('13zb1h'):
                print('\n\n ' + hex(line) + ' \n ' + y1,'\n')
                file=open(u"Addr.Info.txt","a")
                file.write('\n '+hex(line)+' | '+ y1)
                file.close()
                sleep(3)
                print('\n continue...\n')
                sleep(1)

            if y1 == "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so":
                print('\n\n Target found!!' + hex(line) + ' \n ' + y1,'\n')
                file=open(u"16j.Target.Info.txt","a")
                file.write('\n '+hex(line)+' | '+ y1)
                file.close()
                sleep(3)
                print('\n\n STOP!')
                sleep(1)
                break

Similar structure, without "random.sample" limit, with "random.randrange" there is no such limit...

Code:

import tqdm
import time
import random
import bit
from bit import *
from time import sleep
from tqdm import tqdm
t = time.ctime()
print('',t)
print('\n ============== ================= ==RANDOM HUNTER== ================= ==============\n\n')
list=[]
list.clear()
i = 4000000
print(' generate',str(i),'Random Keys..... ')
while len(list)<=i:
    a1 = random.randrange(0x20000000000000000,0x3ffffffffffffffff)
    list.append(a1) 
    if len(list)==i:
        line_count=0
        print ('',i,'Keys DONE !!')
        sleep(1)
        print ('\n Start Scanning..!! \n')
        sleep(2)
        for line in tqdm(list):
            line != "\n"
            seed=str(line)
            key = Key.from_int(line)
            y1 = key.address
            line_count+=1
            
            if y1.startswith('13zb1h'):
                print('\n\n ' + hex(line) + ' | ' + y1,'\n')
                print(' continue...\n')
                sleep(1)

            if y1 == "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so":
                print('\n\n Target found!!' + hex(line) + ' \n ' + y1,'\n')
                file=open(u"16j.Target.Info.txt","a")
                file.write('\n '+hex(line)+' | '+ y1)
                file.close()
                sleep(3)
                wait = input("Press Enter to Exit.")
                sleep(1)
                exit()

            if line_count==i:
                list.clear()

    if len(list)==0:
        print('\n generate',str(i),'Random Keys..... ')

[zahid888]

I am the creator.

You are quite right, 161-256 are silly.  I honestly just did not think of this.  What is especially embarrassing, is this did not occur to me once, in two years.  By way of excuse, I was not really thinking much about the puzzle at all.

I will make up for two years of stupidity.  I will spend from 161-256 to the unsolved parts, as you suggest.  In addition, I intend to add further funds.  My aim is to boost the density by a factor of 10, from 0.001*length(key) to 0.01*length(key).  Probably in the next few weeks.  At any rate, when I next have an extended period of quiet and calm, to construct the new transaction carefully.

A few words about the puzzle.  There is no pattern.  It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty).  It is simply a crude measuring instrument, of the cracking strength of the community.

Finally, I wish to express appreciation of the efforts of all developers of new cracking tools and technology.  The "large bitcoin collider" is especially innovative and interesting!

Need more hints for puzzle 64

[ccqt]

zahid888 is NOT the creator and I can prove it.  This is a puzzle, and I've found a major piece of it.  I need someone with advanced programming skills.  I'm willing to share what I've learned with the right person, for half of the coins.  I've figured out how to reduce the possibilities infinitely, like literally down to thousands, from such an incomprehensibly large number that no one can really understand. 

I'm thinking about doing a youtube video on it.  If I get enough support here I will. 

[devjorge]

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)

[jhonjhon]

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.. Its better to be safe than sorry.

[Feron]

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.

[fxsniper]

I think all method with "random" any technic or idea all it never works.
but method calculate or algorithm may be can work possible

[wipall]

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).

[salah98]

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