Author

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

full member
Activity: 431
Merit: 105
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.
full member
Activity: 541
Merit: 137

you can follow this topic on new thread update at here

https://bitcointalksearch.org/topic/bitcoin-challenge-transaction-1000-btc-total-bounty-to-solvers-updated-5218972

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
member
Activity: 406
Merit: 47
full member
Activity: 541
Merit: 137
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
full member
Activity: 431
Merit: 105
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
jr. member
Activity: 184
Merit: 3
Or such an option.

Take 1000 samples of 50 from the set 00-99 ()

>>> 1

>>> 2

>>> 3

>>> 4

>>> 5
480 huuuuuuuuuurraaaaaaaaaa... ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99'] 100     ['46', '77', '96', '34', '68', '95', '45', '60', '30', '96', '90', '63', '29', '23', '56', '65', '28', '84', '69', '43', '84', '08', '84', '36', '64', '83', '70', '91', '20', '28', '73', '73', '58', '68', '72', '92', '61', '85', '70', '52', '24', '58', '55', '54', '54', '93', '12', '64', '44', '31'] 50     ['30'] ['56'] ['83'] ['77'] ['31'] ['20'] ['64'] ['20'] ['28'] ['55']

5 samples come across

['46, '77', '96', '34', '68', '95', '45', '60', '30', '96', '90', '63', '29', '23', '56', '65', '28', '84', '69', '43', '84', '08', '84', '36', '64', '83', '70', '91', '20', '28', '73', '73', '58', '68', '72', '92', '61', '85', '70', '52', '24', '58', '55', '54', '54', '93', '12', '64', '44', '31'] 50

['30'] ['56'] ['83'] ['77'] ['31'] ['20'] ['64'] ['20'] ['28'] ['55']

and that only 5000 mixed sets in which dropped out with the required number.

now we take each of these 5000 sets and select 1000 from each of them, 30 samples.

finds the first time (but you may need 20-30, etc.)

174 huuuuuuuuuurraaaaaaaaaa... ['46', '77', '96', '34', '68', '95', '45', '60', '30', '96', '90', '63', '29', '23', '56', '65', '28', '84', '69', '43', '84', '08', '84', '36', '64', '83', '70', '91', '20', '28', '73', '73', '58', '68', '72', '92', '61', '85', '70', '52', '24', '58', '55', '54', '54', '93', '12', '64', '44', '31'] 50     ['46', '73', '31', '84', '83', '95', '63', '72', '95', '68', '68', '58', '30', '77', '56', '83', '20', '45', '95', '84', '64', '28', '65', '70', '85', '55', '08', '85', '68', '83'] 30     ['30'] ['56'] ['83'] ['77'] ['31'] ['20'] ['64'] ['20'] ['28'] ['55']

666 huuuuuuuuuurraaaaaaaaaa... ['46', '77', '96', '34', '68', '95', '45', '60', '30', '96', '90', '63', '29', '23', '56', '65', '28', '84', '69', '43', '84', '08', '84', '36', '64', '83', '70', '91', '20', '28', '73', '73', '58', '68', '72', '92', '61', '85', '70', '52', '24', '58', '55', '54', '54', '93', '12', '64', '44', '31'] 50     ['92', '56', '73', '12', '34', '73', '96', '90', '95', '58', '20', '93', '83', '60', '63', '84', '58', '68', '31', '28', '77', '23', '72', '54', '55', '30', '64', '70', '93', '23'] 30     ['30'] ['56'] ['83'] ['77'] ['31'] ['20'] ['64'] ['20'] ['28'] ['55']

now can search further in the same way for 17 parts, but it takes a long time or choose from 30

and then, in the end, for the first choice from 100 to 50 we take 1000 and then for each 1000 1000 already 1000000 and 17 parts from 30 20-30 20000000 (using a stirring of 17 on a PC it takes 1 stirring per day approximately)

or search in another way

how to choose from 30 parts.
can create as many sets as you like from fixed positions and run reading lines

we have a string blablabla

123456789

pos 2 4 6 8
     2 4 6 8 > 2468
pos 1 3 4 7
     1 3 4 7 > 1347

n this case,need to run only 1000x1000 1,000,000 lines (in several copies of the program, for each program you need its own set of random 1,000,000)

and position traps when fishing from 30 parts what you can think of

pos 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17...
pos 2 4 6 8 10 12 14 16...
pos 1 3 7 9...
pos 25 12 20 3...

***
Or try to iterate over the private keys (not compressed in short). Someone could still hack this.
https://twitter.com/UnderTheBreach/status/1303316723186139136?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1303316723186139136%7Ctwgr%5E%7Ctwcon%5Es1_&ref_url=https%3A%2F%2F2bitcoins.ru%2Fvzlomat-koshelek-s-69370-bitkoinami%2F forwarded https://www.blockchain.com/btc/address/bc1qa5wkgaew2dkv56kfvj49j0av5nml45x9ek9hz6

And they wrote that out of 15+ a password from a set of letters and numbers cannot be cracked faster than 100 years.

Or the author of the puzzle, if bitcoin starts to cost 500 thousand dollars (0,6 > ~ 300000$), will bring everything back to himself. Cheesy Either he owns thousands of bitcoins and doesn't care or we need to hurry.  Roll Eyes

We have 17 to 15 characters (123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz) long.

the private owner himself lenght is 51...

5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip + 17 or

5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7 + 16
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8 + 16
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9 + 16

etc...

Quote
from bit import Key
from bit.format import bytes_to_wif
import random
import time

i=1
while i <= 100000000:
    
    try:
        while True:
            
            a = "5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip"
            c1 = random.choice("789")
            c2 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c3 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c4 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c5 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c6 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c7 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c8 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c9 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c10 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c11 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c12 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c13 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c14 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c15 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c16 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c17 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            
            b = (a+c1+c2+c3+c4+c5+c6+c7+c8+c9+c10+c11+c12+c13+c14+c15+c16+c17)
            
            print(b)
            key1 = Key(b)
            wif1 = bytes_to_wif(key1.to_bytes(), compressed=True)
            key2 = Key(wif1)
            addr1 = key2.address
            
            print(addr1)
            
            list =["16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN","13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so","1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9",
                   "1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ","19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG","17aPYR1m6pVAacXg1PTDDU7XafvK1dxvhi"]

            if addr1 in list:
                print(key2,wif1)
                s5 = str(b)
                f=open(u"C:/a.txt","a")
                f.write(s5 + '\n')
                f.close()
                break
            
    except:
      
        pass


    i=i+1

[/size]

Quote
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9TCtAvUfKhoFxYTc9
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7bv5RMSuoznp2uhqe
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8BrrMP9oEfbvD94YX
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9a1SzEwmAvpT26x4C
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9KdgPtUyZKWvJC4ZF
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8fH4ZZ69fWw6BdtDv
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip78tWUnQ6qF8yXcaY2
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7rJRmZ6friVeM1qc6
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9UAa2ekurdKcPF4My
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8dYitTcwJfxXCGfeZ
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9bKNcfneeyf6CUUgw
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9YbKx2dJB5efJtfNy
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9Ygtosb3g6gF4Y5DM
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9ovmK8kCJkCfDEi9Y
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9bAdqx6zqtTmwKH6x
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip817D7YjqpzHBJhqWx
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9n7yTUMxnivSB5Vd7
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8KtL7pfLmPRUxZPFL
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8MRboemYp2iaY5mph
[/size]

did not delve into the details of how he generates it this private but the main part goes through step by step (for each of 123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz the same in order) as an option, see how much it will roll on the counter between the puzzles, maybe there is something to attach to, or it will copy dec.

It is not yet clear where he might be

1Me6EfpwZK5kQziBwBfvLiHjaPGxCKLoJi      | 4611686018427387903                     
1NpYjtLira16LfGbGwZJ5JbDPh3ai9bjf4        | 9223372036854775807  8993229949524469768
16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN   | 18446744073709551615                 
18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe | 36893488147419103231                   

Quote
from bit import Key
from bit.format import bytes_to_wif

#print (int("0000000000000000000000000000000000000000000000007CCE5EFDACCF6808",16))

i = 9223372036854775807          # 9223372036854775807     #44218742292676575 1461501637330902918203684832716283019655932542464
while i <= 18446744073709551615  : # 18446744073709551615 115792089237316195423570985008687907852837564279074904382605163141518161494336
    key1 = Key.from_int(i)

    wif = bytes_to_wif(key1.to_bytes(), compressed=False)
    wif2 = bytes_to_wif(key1.to_bytes(), compressed=True)
    key2 = Key(wif)
    key1 == key2
        #print(hex(i))
        #print(key1.address)
        #print(key2.address)
    print(i,wif,wif2) #(i,wif,wif2,key1.address,key2.address)

    i=i+1
[/size]
full member
Activity: 431
Merit: 105
asic pool or solo miner
github.com/achow1o1

gunchefi i send you looot of btc send me the file, my asic,

waiting for the files. Tongue
member
Activity: 158
Merit: 39
Link

https://github.com/iceland2k14/bsgs


I bought your code but There is a password ?

   Tongue

this is not the pvk asic pool or solo miner, just a bsgs multi pub search made by iceland somethin with help of albert something,

Code:
[+] Starting Program : BSGS mode
[+] Reading Baby table from file complete in : 0.75554 sec
[+] seq value: 500000000000    m value : 20000000
[+] Search Range: 0x800000000000000000000000000000  to  0xffffffffffffffffffffffffffffff
                                                                [+] k1: 0xae0ca830af9a9fac558c5c5ceef5a7
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xa3c7ed3d86bbe4181c3a37221a0da5
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xd4c90c752e4627f124b31bdb94c4f2
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xb6c900e87428a2a12cfb90b8484b96
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0x9a28f237e7491f5fae336393ce0b94
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xbf1693d4d366372015ad7f12a0076b
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xc4cfaf5131dfe553dfbb2ee60078f8
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0x9d37da4812bd1caf1c629cf77c1056
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xec2d260f7258b19b569cedad37a639
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xbdcc2a1a175d930227f3082ce3bafd
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0x87347fd4e8ab0cf01a45c62e779cbd
PVK not found. 500.00000 Billion scanned in 0.22 sec. New range [+] k1: 0x9b5b02e9ee0563e12d7138f0cc8544
PVK not found. 500.00000 Billion scanned in 0.22 sec. New range [+] k1: 0x965261549b3f3ace040172405af75e
PVK not found. 500.00000 Billion scanned in 0.22 sec. New range [+] k1: 0xd84c7099e7ec03a27f23df9e0f2582
PVK not found. 500.00000 Billion scanned in 0.22 sec. New range [+] k1: 0xc3d2bfd31bd7aa525327bf74e4f6a0
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xbb2d00a87e49e7a91536771fed119a
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xbdf6b4a3ff2cbcffa33f87b104fb3c
full member
Activity: 431
Merit: 105
I bought your code but There is a password ?

   Tongue

this is not the pvk asic pool or solo miner, just a bsgs multi pub search made by iceland somethin with help of albert something,

Code:
[+] Starting Program : BSGS mode
[+] Reading Baby table from file complete in : 0.75554 sec
[+] seq value: 500000000000    m value : 20000000
[+] Search Range: 0x800000000000000000000000000000  to  0xffffffffffffffffffffffffffffff
                                                                [+] k1: 0xae0ca830af9a9fac558c5c5ceef5a7
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xa3c7ed3d86bbe4181c3a37221a0da5
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xd4c90c752e4627f124b31bdb94c4f2
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xb6c900e87428a2a12cfb90b8484b96
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0x9a28f237e7491f5fae336393ce0b94
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xbf1693d4d366372015ad7f12a0076b
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xc4cfaf5131dfe553dfbb2ee60078f8
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0x9d37da4812bd1caf1c629cf77c1056
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xec2d260f7258b19b569cedad37a639
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xbdcc2a1a175d930227f3082ce3bafd
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0x87347fd4e8ab0cf01a45c62e779cbd
PVK not found. 500.00000 Billion scanned in 0.22 sec. New range [+] k1: 0x9b5b02e9ee0563e12d7138f0cc8544
PVK not found. 500.00000 Billion scanned in 0.22 sec. New range [+] k1: 0x965261549b3f3ace040172405af75e
PVK not found. 500.00000 Billion scanned in 0.22 sec. New range [+] k1: 0xd84c7099e7ec03a27f23df9e0f2582
PVK not found. 500.00000 Billion scanned in 0.22 sec. New range [+] k1: 0xc3d2bfd31bd7aa525327bf74e4f6a0
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xbb2d00a87e49e7a91536771fed119a
PVK not found. 500.00000 Billion scanned in 0.18 sec. New range [+] k1: 0xbdf6b4a3ff2cbcffa33f87b104fb3c
jr. member
Activity: 31
Merit: 4

this is not the original link it is 100% SCAM


[/quote]

Thats exactly thé sames files That i bought from thé github but here for only 0.001 btc ...
they are password protected And i don’t know how to contact the github guy
member
Activity: 158
Merit: 39
jr. member
Activity: 31
Merit: 4
I bought your code but There is a password ?

jr. member
Activity: 184
Merit: 3
WanderingPhilospher, math09183 Ok. Ie it makes no sense? How long does it take to mix (sort of "shuffling" or "random") 20 parts to find the desired result on gpu less than a second? You have the opportunity to check the search time from 20,30,40 parts? (if gpu searches by random mixing only 1000 numbers per second then this is a problem. and how then BitCrack works, what's the difference for him to step by step or mix.)

we have a set from 00 to 99. of them we need 10 necessary ones (for 20 dec pz lenght), but increasing the sample (10,20,30 ...) for mixing we increase the chance of catching the right one from the set from 00 to 99.  

sample 50/50 (throw a coin)


I would have to see this in action to fully understand it all. Program? How to implement the mixing? How do you go from mixing to checking the keys? Use one program to mix and then another to check the keys??
Well, this is already a question of writing a program, in theory, gpu acceleration is enough only for check the keys. And depending on which programming language your, libraries or ready-made scripts should be on the internet. You wrote that gpu works for you, you created the program yourself or use some of the puzzle theme (bitcrack or kangaroo)? what prevents you if you created the program yourself, add on top (before checking the gpu keys) a ready-made script from the Internet mixing (random shuffle function) in C ++ or OpenCl/Gl gpu cuda.  

In general, let's find at least 1 pz and pay brichard19 he will write to us as needed  Grin


I have taken programs developed, Kangaroo, VS, BitCrack (not using bitcrack anymore) and have tinkered with them along with python and batch scripts to do what I want it to do. Doesn't mean my ideas are the best, just I wanted to do something and set out to do it. I am not a programmer but I can study code and make some changes.  I was/am still trying to figure out your mixing. Can you explain via an example?

For the #64, how would the mixing work, mix what, and do what?
There is nothing special to understand)). I already wrote once.

We're searching for a number, let's say it 30568377312064202855

break it into pieces of 2 digits 30 56 83 77 31 20 64 20 28 55

We just swap them and get the number you need. python  random shuffle uses something of Fisher–Yates https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle (will gpu speed it up?)

Quote

import random
import time

Nn =['30', '56', '83', '77', '31', '20', '64', '20', '28', '55']
nnn = Nn # *1 *10000000
print ("set lenght",len(Nn),Nn)

count = 0

#while True:
j=1
while j<=50000000:

    d = ''.join(random.sample(Nn,len(Nn)))
    dd = (d)[0:20]
    #print(dd)
    a = int(dd)
    if a == 30568377312064202855:
        count += 1
        print(count,"find..............................",a)
        time.sleep(60.0)
        break
    else:
        count += 1
        #print(a)
        pass

    j=j+1


Quote
77203164833020285655
55832064312030567728
20772856302055316483
20283077315556208364
28305664208320773155
20558364282056307731
55286483203056317720
56303155837728202064
56308377202831206455
28567720643031552083
30312056206483772855
56643155778320202830
30205531772064832856
83316430205528562077
83203120566430552877
77835628306420553120
20552083642856303177
83552028775631206430
77566428208331552030
83645620282077305531
20553128567764208330
83302831647720565520
...

2175109 find.............................. 30568377312064202855

2175109 mileage permutation steps.

we can increase the number of parts to 15-20-30 ['30', '56', '83', '77', '31', '20', '64', '20', '28', '55'] > ['30', '56', '83', '77', '31', '20', '64', '20', '28', '55', '30', '56', '83', '77', '31', '20', '64', '20', '28', '55'] this will increase the search time but will increase the dropout of the parts we need to compose the desired number.


in other words, we need to find "abc" from the set "abcdef"

we choose from "abcdef" any letters and mix them

"cde"

dec
ecd
edc
...

did not find we take others

"bdf"
fdb
dbf
fbd
...

we can take all the letters and mix them (cutting to the length we need)
"abcdef"

defabc > def
bcdaef > bcd
abcdef > abc find!

How mixing itself works in python libraries should be seen in the documentation (https://docs.python.org/3/library/random.html) or in the scripts libraries (or come up with your own version).

our puzzle numbers consist of numbers

    ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09',
     '10', '11', '12', '13', '14', '15', '16', '17', '18', '19',
     '20', '21', '22', '23', '24', '25', '26', '27', '28', '29',
     '30', '31', '32', '33', '34', '35', '36', '37', '38', '39',
     '40', '41', '42', '43', '44', '45', '46', '47', '48', '49',
     '50', '51', '52', '53', '54', '55', '56', '57', '58', '59',
     '60', '61', '62', '63', '64', '65', '66', '67', '68', '69',
     '70', '71', '72', '73', '74', '75', '76', '77', '78', '79',
     '80', '81', '82', '83', '84', '85', '86', '87', '88', '89',
     '90', '91', '92', '93', '94', '95', '96', '97', '98', '99']

we can randomly choose 10-20-30 parts from them and mix them in search of the number we need (looking for 10 needed out of a 100 or search for several puzzles at once 10 11 12 13... trimming the length we need programmatically).


full member
Activity: 431
Merit: 105
    Tongue

hi

sharing is caring,

what is that the app, from satoshidisk
full member
Activity: 1162
Merit: 237
Shooters Shoot...
WanderingPhilospher, math09183 Ok. Ie it makes no sense? How long does it take to mix (sort of "shuffling" or "random") 20 parts to find the desired result on gpu less than a second? You have the opportunity to check the search time from 20,30,40 parts? (if gpu searches by random mixing only 1000 numbers per second then this is a problem. and how then BitCrack works, what's the difference for him to step by step or mix.)

we have a set from 00 to 99. of them we need 10 necessary ones (for 20 dec pz lenght), but increasing the sample (10,20,30 ...) for mixing we increase the chance of catching the right one from the set from 00 to 99.  

sample 50/50 (throw a coin)


I would have to see this in action to fully understand it all. Program? How to implement the mixing? How do you go from mixing to checking the keys? Use one program to mix and then another to check the keys??
Well, this is already a question of writing a program, in theory, gpu acceleration is enough only for check the keys. And depending on which programming language your, libraries or ready-made scripts should be on the internet. You wrote that gpu works for you, you created the program yourself or use some of the puzzle theme (bitcrack or kangaroo)? what prevents you if you created the program yourself, add on top (before checking the gpu keys) a ready-made script from the Internet mixing (random shuffle function) in C ++ or OpenCl/Gl gpu cuda. 

In general, let's find at least 1 pz and pay brichard19 he will write to us as needed  Grin


I have taken programs developed, Kangaroo, VS, BitCrack (not using bitcrack anymore) and have tinkered with them along with python and batch scripts to do what I want it to do. Doesn't mean my ideas are the best, just I wanted to do something and set out to do it. I am not a programmer but I can study code and make some changes.  I was/am still trying to figure out your mixing. Can you explain via an example?

For the #64, how would the mixing work, mix what, and do what?
jr. member
Activity: 184
Merit: 3
WanderingPhilospher, math09183 Ok. Ie it makes no sense? How long does it take to mix (sort of "shuffling" or "random") 20 parts to find the desired result on gpu less than a second? You have the opportunity to check the search time from 20,30,40 parts? (if gpu searches by random mixing only 1000 numbers per second then this is a problem. and how then BitCrack works, what's the difference for him to step by step or mix.)

we have a set from 00 to 99. of them we need 10 necessary ones (for 20 dec pz lenght), but increasing the sample (10,20,30 ...) for mixing we increase the chance of catching the right one from the set from 00 to 99.  

sample 50/50 (throw a coin)


I would have to see this in action to fully understand it all. Program? How to implement the mixing? How do you go from mixing to checking the keys? Use one program to mix and then another to check the keys??
Well, this is already a question of writing a program, in theory, gpu acceleration is enough only for check the keys. And depending on which programming language your, libraries or ready-made scripts should be on the internet. You wrote that gpu works for you, you created the program yourself or use some of the puzzle theme (bitcrack or kangaroo)? what prevents you if you created the program yourself, add on top (before checking the gpu keys) a ready-made script from the Internet mixing (random shuffle function) in C ++ or OpenCl/Gl gpu cuda. 

In general, let's find at least 1 pz and pay brichard19 he will write to us as needed  Grin

member
Activity: 158
Merit: 39
Technical question - can somebody point out how author created this puzzle with deterministic wallet, not shure how masking could be done (and with what deterministic wallet in early 2015)?
"It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty)."

Thnx and good luck for fighters!
full member
Activity: 1162
Merit: 237
Shooters Shoot...
WanderingPhilospher, math09183 Ok. Ie it makes no sense? How long does it take to mix (sort of "shuffling" or "random") 20 parts to find the desired result on gpu less than a second? You have the opportunity to check the search time from 20,30,40 parts? (if gpu searches by random mixing only 1000 numbers per second then this is a problem. and how then BitCrack works, what's the difference for him to step by step or mix.)

we have a set from 00 to 99. of them we need 10 necessary ones (for 20 dec pz lenght), but increasing the sample (10,20,30 ...) for mixing we increase the chance of catching the right one from the set from 00 to 99.  

sample 50/50 (throw a coin)


I would have to see this in action to fully understand it all. Program? How to implement the mixing? How do you go from mixing to checking the keys? Use one program to mix and then another to check the keys??
jr. member
Activity: 102
Merit: 6
https://satoshidisk.com/pay/CBd7TZ
The public key of the Bitcoin wallet from Puzzle 64 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN. I can't crack the private key with Kangaroo Sad


The public key of this address has not been exposed, nobody but the owner of the puzzle can give it to you.
I guess you've been scammed.


I used the site https://iancoleman.io/bitcoin-key-compression/, if you enter this public key, the compression address appears 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN. However, I am using Kangaroo and it doesn't find anything. Perhaps the hex range is incorrect?

i am using gtx 970 and win10, how can i use kangaroo, i tried but can be run the kangaroo, can you help me?
Jump to: