Bitcoin puzzle transaction ~32 BTC prize to who solves it

[as9ardia]

how you make the bottom part of your code search the 64th puzzle and save it if found
wow andzhig respect. you really great in these things man.
thanks

You can use open() function + parameter to open/read/write/append your result into a file
parameters:
'a' (Append) will append to the end of the file
'w' (Write) will overwrite any existing content
'r' (Read) will read from file

This code I use to scan #64 using python 3.xxx:

Code:

import binascii, blocksmith

a = 2**63
b = 2**64-1
prehex = '000000000000000000000000000000000000000000000000' #48 digit 0
wallettofind = '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN'
fwrite = open('YourFileName.txt', 'w')

print('Scan is Running')
for i in range(a,b):
    privhex = hex(i)[2:]
    dumppriv = prehex+str(privhex)
    walletscan = blocksmith.BitcoinWallet.generate_compressed_address(dumppriv)
    if walletscan == wallettofind:
        fwrite.write('Key: '+ str(privhex) + ' ( '+str(walletscan)+' ) \n')
        break
else:
    #fwrite.write('Not Found!!!') if you set b value less than 2**64-1 then you can use this i.e b= 2**63+1000000000 and will only scan for 1000000000 keys between 9223372036854775808 (2**63) to 9223372037854775808
fwrite.close()
print('Scan Finish!')

*if the YourFileName.txt file does not exist it will create automatically

if you want to test the code with a small range. let say puzzle #25
then you can change a,b, prehex and wallettofind value like this:

Code:

a = 2**24
b = 2**25-1
prehex = '000000000000000000000000000000000000000000000000000000000' #57 digit 0
wallettofind = '15JhYXn6Mx3oF4Y7PcTAv2wVVAuCFFQNiP' #Puzzle no 25

[fxsniper]

you can follow this topic on new thread update at here

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

this thread is older and long

[as9ardia]

you can follow this topic on new thread update at here

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

this thread is older and long

but you can found puzzle creator comment on this thread. (just one comment). and it would be better to read all about this puzzle on all related info/thread

btw, I read almost all of the thread, including the locked one and you've mentioned above

[dextronomous]

This code I use to scan #64 using python 3.xxx:

Code:

import binascii, blocksmith

a = 2**63
b = 2**64-1
prehex = '0000000000000000000000000000000000000000000000007CCE5EFDACCF6808'
wallettofind = '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN'
fwrite = open('YourFileName.txt', 'a')

print('Scan is Running')
for i in range(a,b):
    privhex = hex(i)[2:]
    dumppriv = prehex+str(privhex)
    walletscan = blocksmith.BitcoinWallet.generate_compressed_address(dumppriv)
    if walletscan == wallettofind:
        fwrite.write('Key: '+ str(privhex) + ' ( '+str(walletscan)+' ) \n')
        break
else:
    #fwrite.write('Not Found!!!') if you set b value less than 2**64-1 then you can use this i.e b= 2**63+1000000000 and will only scan for 1000000000 keys between 9223372036854775808 (2**63) to 9223372037854775808
fwrite.close()
print('Scan Finish!')

Do i just add this one if only wanting the 64th to be searched,
0000000000000000000000000000000000000000000000007CCE5EFDACCF6808 so adding this
added the a append, anything needed to be printed onscreen while searching?
like speed or time left or
#print(hex(i))
#print(key1.address)
#print(key2.address)
  print(i,wif,wif2) #(i,wif,wif2,key1.address,key2.address)
any of these, i know i already asked to much.

[fxsniper]

but you can found puzzle creator comment on this thread. (just one comment). and it would be better to read all about this puzzle on all related info/thread

btw, I read almost all of the thread, including the locked one and you've mentioned above

Ok, I still read info from this thread

[1083ivangod]

This is just a bot game.

[Andzhig]

Or consider an option divide and conquer https://en.wikipedia.org/wiki/Divide-and-conquer_algorithm (from the brute-force family)

take our desired number and decompose it into terms

30568377312064202855

3 0,   5 6,    8 3,   7 7,   3 1,   2 0,    6 4,   2 0,   2 8,   5 5
 3      11      11     14      4      2       10      2      10    10
    14               25              6               12             20
              39                              18                      20  
                               57  <==left side                    20  <==right side
                                                     77

how to organize it correctly? we have 20 numbers long at some point we have 5 parts (here, for example, with even https://res.cloudinary.com/practicaldev/image/fetch/s--JMbxW5kY--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://skerritt.blog/content/images/2019/03/image-35.png). we leave some part (we have 20) and just push it along the script.

import random
def foo(number):
    first = random.randint(0, number)
    second = number - first
    return first, second

while True:

    a = foo(77)

    A=[]
    ost = []

    B=[]


    C1=[]
    C2=[]

    b=a
    A.append(b)

    #print(a,b,A)

    for elem in A:
        for XXX in elem:
            if XXX == 57:                         <==left side
                f = foo(elem[0])
                B.append(f)
                ost.append(elem[1])
                #print(elem,f,ost)

    for AAA in ost:
        if AAA == 20:                              <==right side
  

            D1=[]
            D2=[]
            D3=[]
            D4=[]
            ost2 = []

            for elems in B:
                f1 = foo(elems[0])
                f2 = foo(elems[1])
                C1.append(f1)
                C2.append(f2)
                #ost.append(elem[1])
                #print(elems,f1,f2,C1,C2,ost)


            for elems in C1:
                f1 = foo(elems[0])
                f2 = foo(elems[1])
                D1.append(f1)
                D2.append(f2)
                #ost.append(elem[1])
                #print(D1,D2)

            for elems in C2:
                f1 = foo(elems[0])
                f2 = foo(elems[1])
                D3.append(f1)
                D4.append(f2)
                #ost.append(elem[1])
                #print(D3,D4)

            for elems in ost:
                f1 = foo(elems)
                #f2 = foo(elems[1])
                ost2.append(f1)
                #D4.append(f2)
                #ost.append(elem[1])
                #print(D3,D4)


            #print(D1,D2,D3,D4,ost2)    
            add = D1+D2+D3+D4+ost2
            #print(add)

            End = []

            for elems in add:
                for x in elems:
                #print(elems)
                    f = foo(x)
                    End.append(f)

            End1=[]

            for elems in End:
                for x in elems:
                #print(elems)
                    
                    End1.append(str(x))



            #print(End)
            #print(End1)
            ex = (''.join(End1))
            exx = int(ex)
            exxx = str(exx)
            exxxx = len(exxx)
            if exxxx == 20:
                if exx == 30568377312064202855:
                    print(ex,"length>",len(ex),"   right side>",ost)
                    break
                else:
                    
                    print(exx,exxxx,"   right side>",ost)

33031002842015744120 20    right side> [20]
10493216611310103980 20    right side> [20]
11641140504016533410 20    right side> [20]
30122010327100627463 20    right side> [20]
10002034845003022511 20    right side> [20]
10001615017710012503 20    right side> [20]
11323155020102408390 20    right side> [20]
12000101405020523132 20    right side> [20]
61982180100000315500 20    right side> [20]
22810420011220500164 20    right side> [20]
12760113116251113467 20    right side> [20]
30673057540316161694 20    right side> [20]
10513518702621631511 20    right side> [20]
24141601500100508318 20    right side> [20]
10014352140000001154 20    right side> [20]
30124201718010021413 20    right side> [20]
12531011510613031061 20    right side> [20]
51458219016130231610 20    right side> [20]
53268549001523312981 20    right side> [20]
10011329111100031232 20    right side> [20]
14012110000054926347 20    right side> [20]
20010001146919501118 20    right side> [20]
41513911021200003737 20    right side> [20]
66222231600000021134 20    right side> [20]
18640001450617233863 20    right side> [20]
21041812041510931232 20    right side> [20]
15422601112320080210 20    right side> [20]
12275141002052169371 20    right side> [20]
71040404700376523213 20    right side> [20]
11281000052352001442 20    right side> [20]
86241148022712081110 20    right side> [20]
19131254415022171667 20    right side> [20]
20030134611000015140 20    right side> [20]
20500352114191515212 20    right side> [20]
84119219102000100884 20    right side> [20]
20245012000100421017 20    right side> [20]
40326302060701147517 20    right side> [20]
29620223100071049380 20    right side> [20]
20211333210051241928 20    right side> [20]
36371432318510281649 20    right side> [20]
15177040193800029542 20    right side> [20]
10221161186100032114 20    right side> [20]
76808034218201702369 20    right side> [20]
12000045240011121215 20    right side> [20]
10003023349060811081 20    right side> [20]

***
in this crap, the output ends up going through a set from 0-0 to 9-9 (but not always).

[['0', '0'], ['0', '1'], ['0', '2'], ['0', '3'], ['0', '4'], ['0', '5'], ['0', '6'], ['0', '7'], ['0', '8'], ['0', '9'], ['1', '1'], ['1', '2'], ['1', '3'], ['1', '4'], ['1', '5'], ['1', '6'], ['1', '7'], ['1', '8'], ['1', '9'], ['2', '2'], ['2', '3'], ['2', '4'], ['2', '5'], ['2', '6'], ['2', '7'], ['2', '8'], ['2', '9'], ['3', '3'], ['3', '4'], ['3', '5'], ['3', '6'], ['3', '7'], ['3', '8'], ['3', '9'], ['4', '4'], ['4', '5'], ['4', '6'], ['4', '7'], ['4', '8'], ['4', '9'], ['5', '5'], ['5', '6'], ['5', '7'], ['5', '8'], ['5', '9'], ['6', '6'], ['6', '7'], ['6', '8'], ['6', '9'], ['7', '7'], ['7', '8'], ['7', '9'], ['8', '8'], ['8', '9'], ['9', '9'], ['9', '8'], ['9', '7'], ['9', '6'], ['9', '5'], ['9', '4'], ['9', '3'], ['9', '2'], ['9', '1'], ['9', '0'], ['8', '7'], ['8', '6'], ['8', '5'], ['8', '4'], ['8', '3'], ['8', '2'], ['8', '1'], ['8', '0'], ['7', '6'], ['7', '5'], ['7', '4'], ['7', '3'], ['7', '2'], ['7', '1'], ['7', '0'], ['6', '5'], ['6', '4'], ['6', '3'], ['6', '2'], ['6', '1'], ['6', '0'], ['5', '4'], ['5', '3'], ['5', '2'], ['5', '1'], ['5', '0'], ['4', '3'], ['4', '2'], ['4', '1'], ['4', '0'], ['3', '2'], ['3', '1'], ['3', '0'], ['2', '1'], ['2', '0'], ['1', '0']] 100

and there are 100 (but not always).

77
***
first num breaking > [(67, 10)]
***
first num> (67, 10) first num left> (55, 12) right ost >  [10]
***
first num left> (55, 12) left> (6, 49) right> (9, 3) ost> [10]
***
left> [(3, 3)] [(45, 4)] right> [(7, 2)] [(0, 3)] ost> [(7, 3)]                           <== loop from this step
***
[(3, 0), (1, 2), (24, 21), (0, 4), (5, 2), (1, 1), (0, 0), (1, 2), (4, 3), (3, 0)]
***
['3', '0', '1', '2', '24', '21', '0', '4', '5', '2', '1', '1', '0', '0', '1', '2', '4', '3', '3', '0']
***
3012242104521100124330 lenght 22
[(0, 3), (0, 3), (18, 27), (4, 0), (1, 6), (0, 2), (0, 0), (0, 3), (6, 1), (0, 3)]
***
['0', '3', '0', '3', '18', '27', '4', '0', '1', '6', '0', '2', '0', '0', '0', '3', '6', '1', '0', '3']
***
0303182740160200036103 lenght 22
[(1, 2), (0, 3), (41, 4), (4, 0), (0, 7), (2, 0), (0, 0), (2, 1), (7, 0), (3, 0)]
***
['1', '2', '0', '3', '41', '4', '4', '0', '0', '7', '2', '0', '0', '0', '2', '1', '7', '0', '3', '0']
***
120341440072000217030 lenght 21


here we can, of course, loop over these 100

and 1 more moment whether there is any sense in it is not clear. if our number 30568377312064202855 turned to 77

then each puzzle has its own number he dances there from 40 to 140 mostly

from 10000000000000000000 to 18446744073709551615

10000000000000000000 1
10000000000000000001 2
10000000000000000002 3
10000000000000000003 4
10000000000000000004 5
10000000000000000005 6
10000000000000000006 7
10000000000000000007 8
10000000000000000008 9
10000000000000000009 10
10000000000000000010 2
10000000000000000011 3
10000000000000000012 4
10000000000000000013 5
10000000000000000014 6
10000000000000000015 7
10000000000000000016 8
10000000000000000017 9
10000000000000000018 10
10000000000000000019 11
10000000000000000020 3
10000000000000000021 4
10000000000000000022 5
10000000000000000023 6
10000000000000000024 7
10000000000000000025 8
10000000000000000026 9
10000000000000000027 10
10000000000000000028 11
10000000000000000029 12
10000000000000000030 4
10000000000000000031 5
10000000000000000032 6
10000000000000000033 7
10000000000000000034 8
10000000000000000035 9

or with a big step

10000000001234567890 46
10000000002469135780 46
10000000003703703670 37
10000000004938271560 46
10000000006172839450 46
10000000007407407340 37
10000000008641975230 46
10000000009876543120 46
10000000011111111010 10
10000000012345678900 46
10000000013580246790 46
10000000014814814680 46
10000000016049382570 46
10000000017283950460 46
10000000018518518350 46
10000000019753086240 46
10000000020987654130 46
10000000022222222020 19
10000000023456789910 55
10000000024691357800 46
10000000025925925690 55
10000000027160493580 46
10000000028395061470 46
10000000029629629360 55
10000000030864197250 46
10000000032098765140 46
10000000033333333030 28
10000000034567900920 46
10000000035802468810 46
10000000037037036700 37
10000000038271604590 46
10000000039506172480 46
10000000040740740370 37
10000000041975308260 46
10000000043209876150 46

etc.

10000000000000000000 1
11123123213123123123 38
12246246426246246246 75
13369369639369369369 112
14492492852492492492 95
15615616065615615615 78
16738739278738738738 115
17861862491861861861 98

is there any point in making several brute-force programs fixed from 40 to 140?...

import random


i =       10000000000000000000
while i<= 18446744073709551615:

    h1 = str(i)

    g1 = ([h1[i:i + 2] for i in range(0, len(h1), 2)])
    #print(g1)

    A=[]
    for elem in g1:
        g2 = ([elem[i:i + 1] for i in range(0, len(elem), 1)])
        A.append(g2)

    #print(A)    
    #print(A[0])

    B = []

    for elems in A:
        result = [int(item) for item in elems]
        v = sum(result)
        B.append(v)
        #print(v)

    #print(B)

    C = []
    g3 = ([B[i:i + 2] for i in range(0, len(B), 2)])
    #print(g3,len(g3))

    for elems in g3:
        result = [int(item) for item in elems]
        v = sum(result)
        C.append(v)
        #print(v)

    #print(C)

    c1 = int(C[0])+ int(C[1])
    c2 = int(C[2])+ int(C[3])
    c3 = int(C[4])

    #print(c1,c2,c3)


    f1= c1+c2
    f2= c3
    #print(f1,f2)

    b1 = f1+f2
    print(i,b1)
    
    i=i+1234567890

[/size]

import random
from bit import Key
import time

list = ["16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN","13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so","1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9",
        "1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ","19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG","1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF",
        "1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU","1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR","12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4",
        "1FWGcVDK3JGzCC3WtkYetULPszMaK2Jksv","1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF","1Bxk4CQdqL9p22JEtDfdXMsng1XacifUtE",
        "15qF6X51huDjqTmF9BJgxXdt1xcj46Jmhb","1ARk8HWJMn8js8tQmGUJeQHjSE7KRkn2t8","15qsCm78whspNQFydGJQk5rexzxTQopnHZ",
        "13zYrYhhJxp6Ui1VV7pqa5WDhNWM45ARAC","14MdEb4eFcT3MVG5sPFG4jGLuHJSnt1Dk2","1CMq3SvFcVEcpLMuuH8PUcNiqsK1oicG2D",
        "1K3x5L6G57Y494fDqBfrojD28UJv4s5JcK","1PxH3K1Shdjb7gSEoTX7UPDZ6SH4qGPrvq","16AbnZjZZipwHMkYKBSfswGWKDmXHjEpSf",
        "19QciEHbGVNY4hrhfKXmcBBCrJSBZ6TaVt","1EzVHtmbN4fs4MiNk3ppEnKKhsmXYJ4s74","1AE8NzzgKE7Yhz7BWtAcAAxiFMbPo82NB5",
        "17Q7tuG2JwFFU9rXVj3uZqRtioH3mx2Jad","1K6xGMUbs6ZTXBnhw1pippqwK6wjBWtNpL","15ANYzzCp5BFHcCnVFzXqyibpzgPLWaD8b",
        "18ywPwj39nGjqBrQJSzZVq2izR12MDpDr8","1CaBVPrwUxbQYYswu32w7Mj4HR4maNoJSX","1JWnE6p6UN7ZJBN7TtcbNDoRcjFtuDWoNL",
        "1CKCVdbDJasYmhswB6HKZHEAnNaDpK7W4n","1PXv28YxmYMaB8zxrKeZBW8dt2HK7RkRPX","1AcAmB6jmtU6AiEcXkmiNE9TNVPsj9DULf",
        "1EQJvpsmhazYCcKX5Au6AZmZKRnzarMVZu","18KsfuHuzQaBTNLASyj15hy4LuqPUo1FNB","15EJFC5ZTs9nhsdvSUeBXjLAuYq3SWaxTc",
        "1HB1iKUqeffnVsvQsbpC6dNi1XKbyNuqao","1GvgAXVCbA8FBjXfWiAms4ytFeJcKsoyhL","12JzYkkN76xkwvcPT6AWKZtGX6w2LAgsJg",
        "1824ZJQ7nKJ9QFTRBqn7z7dHV5EGpzUpH3","18A7NA9FTsnJxWgkoFfPAFbQzuQxpRtCos","1NeGn21dUDDeqFQ63xb2SpgUuXuBLA4WT4",
        "1NLbHuJebVwUZ1XqDjsAyfTRUPwDQbemfv","1MnJ6hdhvK37VLmqcdEwqC3iFxyWH2PHUV","1KNRfGWw7Q9Rmwsc6NT5zsdvEb9M2Wkj5Z",
        "1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6","1GuBBhf61rnvRe4K8zu8vdQB3kHzwFqSy7","17s2b9ksz5y7abUm92cHwG8jEPCzK3dLnT",
        "1GDSuiThEV64c166LUFC9uDcVdGjqkxKyh","1Me3ASYt5JCTAK2XaC32RMeH34PdprrfDx","1CdufMQL892A69KXgv6UNBD17ywWqYpKut",
        "1BkkGsX9ZM6iwL3zbqs7HWBV7SvosR6m8N","1PXAyUB8ZoH3WD8n5zoAthYjN15yN5CVq5","1AWCLZAjKbV1P7AHvaPNCKiB7ZWVDMxFiz",
        "1G6EFyBRU86sThN3SSt3GrHu1sA7w7nzi4","1MZ2L1gFrCtkkn6DnTT2e4PFUTHw9gNwaj","1Hz3uv3nNZzBVMXLGadCucgjiCs5W9vaGz",
        "1Fo65aKq8s8iquMt6weF1rku1moWVEd5Ua","16zRPnT8znwq42q7XeMkZUhb1bKqgRogyy","1KrU4dHE5WrW8rhWDsTRjR21r8t3dsrS3R",
        "17uDfp5r4n441xkgLFmhNoSW1KWp6xVLD","13A3JrvXmvg5w9XGvyyR4JEJqiLz8ZySY3","16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v",
        "1UDHPdovvR985NrWSkdWQDEQ1xuRiTALq","15nf31J46iLuK1ZkTnqHo7WgN5cARFK3RA","1Ab4vzG6wEQBDNQM1B2bvUz4fqXXdFk2WT",
        "1Fz63c775VV9fNyj25d9Xfw3YHE6sKCxbt","1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo","1CD91Vm97mLQvXhrnoMChhJx4TP9MaQkJo",
        "15MnK2jXPqTMURX4xC3h4mAZxyCcaWWEDD","13N66gCzWWHEZBxhVxG18P8wyjEWF9Yoi1","1NevxKDYuDcCh1ZMMi6ftmWwGrZKC6j7Ux",
        "19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg","1M7ipcdYHey2Y5RZM34MBbpugghmjaV89P","18aNhurEAJsw6BAgtANpexk5ob1aGTwSeL",
        "1FwZXt6EpRT7Fkndzv6K4b4DFoT4trbMrV","1CXvTzR6qv8wJ7eprzUKeWxyGcHwDYP1i2","1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy",
        "13Q84TNNvgcL3HJiqQPvyBb9m4hxjS3jkV","1LuUHyrQr8PKSvbcY1v1PiuGuqFjWpDumN","18192XpzzdDi2K11QVHR7td2HcPS6Qs5vg",
        "1NgVmsCCJaKLzGyKLFJfVequnFW9ZvnMLN","1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ","1FTpAbQa4h8trvhQXjXnmNhqdiGBd1oraE",
        "14JHoRAdmJg3XR4RjMDh6Wed6ft6hzbQe9","19z6waranEf8CcP8FqNgdwUe1QRxvUNKBG","14u4nA5sugaswb6SZgn5av2vuChdMnD9E5",
        "174SNxfqpdMGYy5YQcfLbSTK3MRNZEePoy", "1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv"]

def foo(number):
    first = random.randint(0, number)
    second = number - first
    return first, second

vib = random.randint(40, 130) # <== Start

#count = 0

while True:

    a = foo(vib) # <== Start

    A=[]
    ost = []

    B=[]

    C1=[]
    C2=[]

    b=a
    A.append(b)

    #print(a,b,A)

    for elem in A:
        f = foo(elem[0])
        B.append(f)
        ost.append(elem[1])
        #print(elem,f,ost)

    D1=[]
    D2=[]
    D3=[]
    D4=[]
    ost2 = []

    for elems in B:
        f1 = foo(elems[0])
        f2 = foo(elems[1])
        C1.append(f1)
        C2.append(f2)
        #ost.append(elem[1])
        #print(elems,f1,f2,C1,C2,ost)

    for elems in C1:
        f1 = foo(elems[0])
        f2 = foo(elems[1])
        D1.append(f1)
        D2.append(f2)
        #ost.append(elem[1])
        #print(D1,D2)

    for elems in C2:
        f1 = foo(elems[0])
        f2 = foo(elems[1])
        D3.append(f1)
        D4.append(f2)
        #ost.append(elem[1])
        #print(D3,D4)

    for elems in ost:
        f1 = foo(elems)
        #f2 = foo(elems[1])
        ost2.append(f1)
        #D4.append(f2)
        #ost.append(elem[1])
        #print(D3,D4)

    #print(D1,D2,D3,D4,ost2)    
    add = D1+D2+D3+D4+ost2
    #print(add)
    count = 0
    i=1
    while i <=100000:                          #<== LOOP

        count += 1
        End = []

        for elems in add:
            for x in elems:
            #print(elems)
                f = foo(x)
                End.append(f)

        End1=[]

        for elems in End:
            for x in elems:
            #print(elems)
                
                End1.append(str(x))

        #print(End)
        #print(End1)
                
        #time.sleep(0.02)
        
        ex = (''.join(End1))
        exx = int(ex)
        exxx = str(exx)
        exxxx = len(exxx)
        if exxxx >= 20:

            #time.sleep(0.02)
            
            #count += 1
            
            ran = exx
            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(count,ran,exxxx,addr1) #(count,ran,exxxx,addr1)

        i=i+1
    print("loop end...")
    count = 0
    pass

[/size]

[Matic]

I don't believe there could be that big price

[Markzuberg64]

Can you please check your PM Sir.

How do y'all know how many bits a public key is?

It is not possible to know the private key bit length from the public key

MrFreeDragon, I have question for you if you can explain to me please !! how brainless can find that those address are 100bits ?
let think that he take the 110 address and try to add negative hex numbres to reduce the bit ,right !! but even that how he can be sure that the numbre that he add make address from 110bit to 100bit !!? that is really weird
the only thing that we know is 2^n = 2^(n-1) + 2^(n-2) .....+ 2^(n-n+1) + 2 !!
but if we have "n" =in range 110 and 111 that make impossible to know of even predict the bit of wallet.
if you have any idea please.

thanks

dear bro
do you like test and proof that my 110bit pubk to 100 bit pubk, mean 10 bit down PM for take test
thankx

[WanderingPhilospher]

Can you please check your PM Sir.

How do y'all know how many bits a public key is?

It is not possible to know the private key bit length from the public key

MrFreeDragon, I have question for you if you can explain to me please !! how brainless can find that those address are 100bits ?
let think that he take the 110 address and try to add negative hex numbres to reduce the bit ,right !! but even that how he can be sure that the numbre that he add make address from 110bit to 100bit !!? that is really weird
the only thing that we know is 2^n = 2^(n-1) + 2^(n-2) .....+ 2^(n-n+1) + 2 !!
but if we have "n" =in range 110 and 111 that make impossible to know of even predict the bit of wallet.
if you have any idea please.

thanks

dear bro
do you like test and proof that my 110bit pubk to 100 bit pubk, mean 10 bit down PM for take test
thankx

He is shifting the pubkeys down; if a pubkey is known, you can point mul or point div by point add. He may use more research in shifting pubkeys down but uses same formula.

[WanderingPhilospher]

This code I use to scan #64 using python 3.xxx:

Code:

import binascii, blocksmith

a = 2**63
b = 2**64-1
prehex = '0000000000000000000000000000000000000000000000007CCE5EFDACCF6808'
wallettofind = '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN'
fwrite = open('YourFileName.txt', 'a')

print('Scan is Running')
for i in range(a,b):
    privhex = hex(i)[2:]
    dumppriv = prehex+str(privhex)
    walletscan = blocksmith.BitcoinWallet.generate_compressed_address(dumppriv)
    if walletscan == wallettofind:
        fwrite.write('Key: '+ str(privhex) + ' ( '+str(walletscan)+' ) \n')
        break
else:
    #fwrite.write('Not Found!!!') if you set b value less than 2**64-1 then you can use this i.e b= 2**63+1000000000 and will only scan for 1000000000 keys between 9223372036854775808 (2**63) to 9223372037854775808
fwrite.close()
print('Scan Finish!')

Do i just add this one if only wanting the 64th to be searched,
0000000000000000000000000000000000000000000000007CCE5EFDACCF6808 so adding this
added the a append, anything needed to be printed onscreen while searching?
like speed or time left or
#print(hex(i))
#print(key1.address)
#print(key2.address)
  print(i,wif,wif2) #(i,wif,wif2,key1.address,key2.address)
any of these, i know i already asked to much.

Keep the prehex as it was...the prehex should be all zeros; the prehex ensures the priv key is 64 characters long (dumppriv = prehex+str(privhex)) before generating pub key. So if you are searching the 64 bit range then the prehex should have 48 zeros...16 chars for 64 bit hex + 48 zeros to pad the string and make it 64 characters

[dextronomous]

wow wandering, thanks for your reply,
needed that information, so great stuff,
then its only showing scan is running,
maybe something to be added like.

Target Addr or Pattern: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
Min Range: 63
Max Range: 65
Magnitude: 100
================
58449828it [20:48:19, 770.99it/s]

or left to search keyspace it is doing this random in this keyspace all not checked for checksum or
is it checked, so could i not ask it to do stdout or ? > to .txt thanks in advance friend.

[WanderingPhilospher]

wow wandering, thanks for your reply,
needed that information, so great stuff,
then its only showing scan is running,
maybe something to be added like.

Target Addr or Pattern: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
Min Range: 63
Max Range: 65
Magnitude: 100
================
58449828it [20:48:19, 770.99it/s]

or left to search keyspace it is doing this random in this keyspace all not checked for checksum or
is it checked, so could i not ask it to do stdout or ? > to .txt thanks in advance friend.

I created something similar awhile back using python 2.7 but looking at the code, it looks like it checks keys sequentially [for i in range(a,b)], from the start of 63 up to 64 bits. Hex range of 8000000000000000:FFFFFFFFFFFFFFFF

[indoarts]

Wonderful thread for people who cant buy fancy GPU like me

[nomadsena]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

[WanderingPhilospher]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

Each page is only generated if visited...basically each page contains say 100 keys/addresses, so the website script knows if you visit page 900 to calculate the keys for 9000 through 9100.

[nioctib.co]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

Each page is only generated if visited...basically each page contains say 100 keys/addresses, so the website script knows if you visit page 900 to calculate the keys for 9000 through 9100.

I have another noob question for you about the website privatekeys.pw. Why they can provide a Search Private Key queries but not Search Address? If their website able to Search Private Key, why can't they do Search Address for their pages?

[nomadsena]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

Each page is only generated if visited...basically each page contains say 100 keys/addresses, so the website script knows if you visit page 900 to calculate the keys for 9000 through 9100.

thanks for the reply but why do they have this at the bottom of their page:"It took a lot of computing power to generate this database. Donations welcome: 1LBCPotwPzBvBcTtd7ADGzCWPXXsZE19j6". i thought all the address were already generated.

[WanderingPhilospher]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

Each page is only generated if visited...basically each page contains say 100 keys/addresses, so the website script knows if you visit page 900 to calculate the keys for 9000 through 9100.

thanks for the reply but why do they have this at the bottom of their page:"It took a lot of computing power to generate this database. Donations welcome: 1LBCPotwPzBvBcTtd7ADGzCWPXXsZE19j6". i thought all the address were already generated.

Negative, or Bitcoin would be at zero...now they may have empty rows setup in a database to fill in as each page is visited but I bet they haven't generated 1 percent of all keys possible.

[WanderingPhilospher]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

Each page is only generated if visited...basically each page contains say 100 keys/addresses, so the website script knows if you visit page 900 to calculate the keys for 9000 through 9100.

I have another noob question for you about the website privatekeys.pw. Why they can provide a Search Private Key queries but not Search Address? If their website able to Search Private Key, why can't they do Search Address for their pages?

probably because their pages are in key sequential order, so if you type in a private key the system knows what web page number it should fall on versus someone searching for an address in which case they would really have to generate private keys to pubkeys...all the way to base58 address. Just more proof they haven't generated all addresses/been through all private keys