Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 252. (Read 229433 times)
I have nothing but free time on my hands lately and I've been like obsessed with it, it's fascinating. I was trying to take a jab at it with some computer experience and I find that all (well most) of the tools out there for cracking aren't compatible with my macbook air (lastest m1 model). I was wondering if anyone had any recommendations fo software or anything considering my circumstance and using a macbook air, I know it's nothing compared to what's out there but it's all I have. Any recommendations because I'm all ears!
The problem with Python is the "print" output, which costs time/processing power, without this, 12000 to 13500 keys/s are generated.. (12000/s = 1036800000 keys/24 hr)
With the print output only 1455.26it/s are generated, which is much too slow.. even 50000 or 100000 keys/s are too slow with a range of 9223372036854775807 possible keys..
Even GPU scanners with more than 150000000 keys/s need more than 1000 years ( 1949.80 ) for this range... (4730400000000000 keys/ year)
With the print output only 1455.26it/s are generated, which is much too slow.. even 50000 or 100000 keys/s are too slow with a range of 9223372036854775807 possible keys..
Even GPU scanners with more than 150000000 keys/s need more than 1000 years ( 1949.80 ) for this range... (4730400000000000 keys/ year)
кинь кoд пocлeдoвaтeльнo
I have revised this code for 64 bit, this code changes the starting point every 1000000 counters..
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...
!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!
It's important to understand the functions so that you know what the code does and you can make conscious changes that work...
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...
!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!
It's important to understand the functions so that you know what the code does and you can make conscious changes that work...
Code:
from bit import *
import random
from time import sleep
count=0
while True:
a = random.randint(2**63, 2**64)
# while a <= 2**64:
for x in range(1000000):
x = x
bina = bin(a)[2:]
zeros = bina.count("0")
# if x in range(1):
if x == 0:
print(" !!!NEW LOOP!!!")
sleep(2)
if zeros >= 1: # "00000000000000000000000000000011111111111111111111111111"
if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
key = Key.from_int(a)
addr = key.address
count+=1
print (hex(a), bina, zeros, str(count))
if addr.startswith('16jY7qLJnxb'):
print(' '+hex(a)+'|'+ addr)
file=open(u"16jY.Info.txt","a")
file.write('\n '+hex(a)+' | '+ addr)
file.close()
sleep(3)
wait = input("Press Enter to continue.")
print(" continue...")
sleep(1)
# else:
# print (' Scan Nr.: ', str(count), end='\r') #pass
a = a +1
pass
Thank you very much for your attention, my friend.
i managed to run the code sequentially.
I scan an average of 500,000,000 addresses a day.
and although the computer is very old
do you think it's too slow?
How many addresses do you scan on average per day?
Puzzle 64 is insane. like i've been running my GPU 2080ti 24/7 and still not getting luck. even though it's only 16 HEX characters.
i'm suspecting, that the address of the puzzle 64 is not in the range that is suppose to be.
What you think guys?
i'm suspecting, that the address of the puzzle 64 is not in the range that is suppose to be.
What you think guys?
quizas los programas que usas saltaron la direccion n64 hay programas con errores
Puzzle 64 is insane. like i've been running my GPU 2080ti 24/7 and still not getting luck. even though it's only 16 HEX characters.
i'm suspecting, that the address of the puzzle 64 is not in the range that is suppose to be.
What you think guys?
i'm suspecting, that the address of the puzzle 64 is not in the range that is suppose to be.
What you think guys?
saludos alguien me podria facilitar el instalador de BitCrack para windows 7 64 bites por favor. I have revised this code for 64 bit, this code changes the starting point every 1000000 counters..
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...
!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!
It's important to understand the functions so that you know what the code does and you can make conscious changes that work...
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...
!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!
It's important to understand the functions so that you know what the code does and you can make conscious changes that work...
Code:
from bit import *
import random
from time import sleep
count=0
while True:
a = random.randint(2**63, 2**64)
# while a <= 2**64:
for x in range(1000000):
x = x
bina = bin(a)[2:]
zeros = bina.count("0")
# if x in range(1):
if x == 0:
print(" !!!NEW LOOP!!!")
sleep(2)
if zeros >= 1: # "00000000000000000000000000000011111111111111111111111111"
if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
key = Key.from_int(a)
addr = key.address
count+=1
print (hex(a), bina, zeros, str(count))
if addr.startswith('16jY7qLJnxb'):
print(' '+hex(a)+'|'+ addr)
file=open(u"16jY.Info.txt","a")
file.write('\n '+hex(a)+' | '+ addr)
file.close()
sleep(3)
wait = input("Press Enter to continue.")
print(" continue...")
sleep(1)
# else:
# print (' Scan Nr.: ', str(count), end='\r') #pass
a = a +1
pass
import random
from time import sleep
count=0
while True:
a = random.randint(2**63, 2**64)
# while a <= 2**64:
for x in range(1000000):
x = x
bina = bin(a)[2:]
zeros = bina.count("0")
# if x in range(1):
if x == 0:
print(" !!!NEW LOOP!!!")
sleep(2)
if zeros >= 1: # "00000000000000000000000000000011111111111111111111111111"
if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
key = Key.from_int(a)
addr = key.address
count+=1
print (hex(a), bina, zeros, str(count))
if addr.startswith('16jY7qLJnxb'):
print(' '+hex(a)+'|'+ addr)
file=open(u"16jY.Info.txt","a")
file.write('\n '+hex(a)+' | '+ addr)
file.close()
sleep(3)
wait = input("Press Enter to continue.")
print(" continue...")
sleep(1)
# else:
# print (' Scan Nr.: ', str(count), end='\r') #pass
a = a +1
pass
Thank you very much for your attention, my friend.
I have revised this code for 64 bit, this code changes the starting point every 1000000 counters..
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...
!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!
It's important to understand the functions so that you know what the code does and you can make conscious changes that work...
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...
!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!
It's important to understand the functions so that you know what the code does and you can make conscious changes that work...
Code:
from bit import *
import random
from time import sleep
count=0
while True:
a = random.randint(2**63, 2**64)
# while a <= 2**64:
for x in range(1000000):
x = x
bina = bin(a)[2:]
zeros = bina.count("0")
# if x in range(1):
if x == 0:
print(" !!!NEW LOOP!!!")
sleep(2)
if zeros >= 1: # "00000000000000000000000000000011111111111111111111111111"
if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
key = Key.from_int(a)
addr = key.address
count+=1
print (hex(a), bina, zeros, str(count))
if addr.startswith('16jY7qLJnxb'):
print(' '+hex(a)+'|'+ addr)
file=open(u"16jY.Info.txt","a")
file.write('\n '+hex(a)+' | '+ addr)
file.close()
sleep(3)
wait = input("Press Enter to continue.")
print(" continue...")
sleep(1)
# else:
# print (' Scan Nr.: ', str(count), end='\r') #pass
a = a +1
pass
import random
from time import sleep
count=0
while True:
a = random.randint(2**63, 2**64)
# while a <= 2**64:
for x in range(1000000):
x = x
bina = bin(a)[2:]
zeros = bina.count("0")
# if x in range(1):
if x == 0:
print(" !!!NEW LOOP!!!")
sleep(2)
if zeros >= 1: # "00000000000000000000000000000011111111111111111111111111"
if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
key = Key.from_int(a)
addr = key.address
count+=1
print (hex(a), bina, zeros, str(count))
if addr.startswith('16jY7qLJnxb'):
print(' '+hex(a)+'|'+ addr)
file=open(u"16jY.Info.txt","a")
file.write('\n '+hex(a)+' | '+ addr)
file.close()
sleep(3)
wait = input("Press Enter to continue.")
print(" continue...")
sleep(1)
# else:
# print (' Scan Nr.: ', str(count), end='\r') #pass
a = a +1
pass
Thank you very much for your attention, my friend.
My remark about you taking my Bitcoins was a joke. You can't take them for the numerical reasons I gave. The best way to get the following prize is to beast force search the scope of the prize. You are right that others with a lot quicker equipment will presumably beat you to the prize.There has been a ton of exertion on this string where individuals attempt to "work out" (all in all conjecture) the normal sub-range withing the following prize reach.
You could look through their speculation at the normal sub-range however again without quicker equipment you will most likely not win the following prize.
You could attempt to look through arbitrarily in the following reach (or their speculation at the normal sub-range). You will presumably still lose yet hello, you could actually luck out.
You could look through their speculation at the normal sub-range however again without quicker equipment you will most likely not win the following prize.
You could attempt to look through arbitrarily in the following reach (or their speculation at the normal sub-range). You will presumably still lose yet hello, you could actually luck out.
I have revised this code for 64 bit, this code changes the starting point every 1000000 counters..
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...
!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!
It's important to understand the functions so that you know what the code does and you can make conscious changes that work...
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...
!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!
It's important to understand the functions so that you know what the code does and you can make conscious changes that work...
Code:
from bit import *
import random
from time import sleep
count=0
while True:
a = random.randint(2**63, 2**64)
# while a <= 2**64:
for x in range(1000000):
x = x
bina = bin(a)[2:]
zeros = bina.count("0")
# if x in range(1):
if x == 0:
print(" !!!NEW LOOP!!!")
sleep(2)
if zeros >= 1: # "00000000000000000000000000000011111111111111111111111111"
if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
key = Key.from_int(a)
addr = key.address
count+=1
print (hex(a), bina, zeros, str(count))
if addr.startswith('16jY7qLJnxb'):
print(' '+hex(a)+'|'+ addr)
file=open(u"16jY.Info.txt","a")
file.write('\n '+hex(a)+' | '+ addr)
file.close()
sleep(3)
wait = input("Press Enter to continue.")
print(" continue...")
sleep(1)
# else:
# print (' Scan Nr.: ', str(count), end='\r') #pass
a = a +1
pass
import random
from time import sleep
count=0
while True:
a = random.randint(2**63, 2**64)
# while a <= 2**64:
for x in range(1000000):
x = x
bina = bin(a)[2:]
zeros = bina.count("0")
# if x in range(1):
if x == 0:
print(" !!!NEW LOOP!!!")
sleep(2)
if zeros >= 1: # "00000000000000000000000000000011111111111111111111111111"
if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
key = Key.from_int(a)
addr = key.address
count+=1
print (hex(a), bina, zeros, str(count))
if addr.startswith('16jY7qLJnxb'):
print(' '+hex(a)+'|'+ addr)
file=open(u"16jY.Info.txt","a")
file.write('\n '+hex(a)+' | '+ addr)
file.close()
sleep(3)
wait = input("Press Enter to continue.")
print(" continue...")
sleep(1)
# else:
# print (' Scan Nr.: ', str(count), end='\r') #pass
a = a +1
pass
Code:
import sys
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice
print('\n B I N A R Y S E E D S C A N Q U A D R O \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
x1 = (x0+n)
a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
a1 = (a1)[2:]
for i in range(x):
a0 = str("1")
a2 = str("0")
a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a3 = (a3)[3:]#.zfill(44)
a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a4 = (a4)[3:]#.zfill(44)
a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a5 = (a5)[3:]#.zfill(44)
a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a6 = (a6)[3:]#.zfill(44)
binb = "".join(a0+a1+a2+a3)
binc = "".join(a0+a1+a2+a4)
bind = "".join(a0+a1+a2+a5)
bine = "".join(a0+a1+a2+a6)
list.append(binb)
list.append(binc)
list.append(bind)
list.append(bine)
if len(list)==x:
line_count=0
for bina in (list):
bina!='\n'
addr = ice.privatekey_to_address(0, True, int(bina,2))
line_count+=1
if addr.startswith('16jY7'): # 16jY7
ran = int(bina,2)
print('',bina, '\n')
sys.stdout.write('\r ' + hex(ran))
sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
ran = int(bina,2)
print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + hex(ran) + ' | ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print(' scan... ', str(n), end='\r')
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice
print('\n B I N A R Y S E E D S C A N Q U A D R O \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
x1 = (x0+n)
a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
a1 = (a1)[2:]
for i in range(x):
a0 = str("1")
a2 = str("0")
a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a3 = (a3)[3:]#.zfill(44)
a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a4 = (a4)[3:]#.zfill(44)
a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a5 = (a5)[3:]#.zfill(44)
a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a6 = (a6)[3:]#.zfill(44)
binb = "".join(a0+a1+a2+a3)
binc = "".join(a0+a1+a2+a4)
bind = "".join(a0+a1+a2+a5)
bine = "".join(a0+a1+a2+a6)
list.append(binb)
list.append(binc)
list.append(bind)
list.append(bine)
if len(list)==x:
line_count=0
for bina in (list):
bina!='\n'
addr = ice.privatekey_to_address(0, True, int(bina,2))
line_count+=1
if addr.startswith('16jY7'): # 16jY7
ran = int(bina,2)
print('',bina, '\n')
sys.stdout.write('\r ' + hex(ran))
sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
ran = int(bina,2)
print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + hex(ran) + ' | ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print(' scan... ', str(n), end='\r')
Ca 42000 keys/s from c000000000000000 to ffffffffffffffff... The sector between 11_________________0 comprise a range of 131071 and will be processed.
The rest of this line are random numbers from 4 different generators..
The counter reflects the number of loops...
B I N A R Y S E E D S C A N Q U A D R O
11_________________0____________________________________________
1110010110110011011010011110001111111110100110111011100101000111
0xe5b369e3fe9bb947 | 16jY7mM6wrpuAy53vKkh7QXm1JNdWK9Myu 19
continue...
1110010011000111001010001111000110100111001000001001110001000100
0xe4c728f1a7209c44 | 16jY7Ezk5et98CVBWYEigGRwWovzhEtaQ3 121
continue...
scan... 192
B I N A R Y S E E D S C A N Q U A D R O
11_________________0____________________________________________
Traceback (most recent call last):
File "11.py", line 41, in
addr = ice.privatekey_to_address(0, True, int(bina,2))
AttributeError: module 'secp256k1' has no attribute 'privatekey_to_address'
Code:
import sys
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice
print('\n B I N A R Y S E E D S C A N Q U A D R O \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
x1 = (x0+n)
a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
a1 = (a1)[2:]
for i in range(x):
a0 = str("1")
a2 = str("0")
a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a3 = (a3)[3:]#.zfill(44)
a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a4 = (a4)[3:]#.zfill(44)
a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a5 = (a5)[3:]#.zfill(44)
a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a6 = (a6)[3:]#.zfill(44)
binb = "".join(a0+a1+a2+a3)
binc = "".join(a0+a1+a2+a4)
bind = "".join(a0+a1+a2+a5)
bine = "".join(a0+a1+a2+a6)
list.append(binb)
list.append(binc)
list.append(bind)
list.append(bine)
if len(list)==x:
line_count=0
for bina in (list):
bina!='\n'
addr = ice.privatekey_to_address(0, True, int(bina,2))
line_count+=1
if addr.startswith('16jY7'): # 16jY7
ran = int(bina,2)
print('',bina, '\n')
sys.stdout.write('\r ' + hex(ran))
sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
ran = int(bina,2)
print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + hex(ran) + ' | ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print(' scan... ', str(n), end='\r')
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice
print('\n B I N A R Y S E E D S C A N Q U A D R O \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
x1 = (x0+n)
a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
a1 = (a1)[2:]
for i in range(x):
a0 = str("1")
a2 = str("0")
a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a3 = (a3)[3:]#.zfill(44)
a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a4 = (a4)[3:]#.zfill(44)
a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a5 = (a5)[3:]#.zfill(44)
a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a6 = (a6)[3:]#.zfill(44)
binb = "".join(a0+a1+a2+a3)
binc = "".join(a0+a1+a2+a4)
bind = "".join(a0+a1+a2+a5)
bine = "".join(a0+a1+a2+a6)
list.append(binb)
list.append(binc)
list.append(bind)
list.append(bine)
if len(list)==x:
line_count=0
for bina in (list):
bina!='\n'
addr = ice.privatekey_to_address(0, True, int(bina,2))
line_count+=1
if addr.startswith('16jY7'): # 16jY7
ran = int(bina,2)
print('',bina, '\n')
sys.stdout.write('\r ' + hex(ran))
sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
ran = int(bina,2)
print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + hex(ran) + ' | ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print(' scan... ', str(n), end='\r')
Ca 42000 keys/s from c000000000000000 to ffffffffffffffff... The sector between 11_________________0 comprise a range of 131071 and will be processed.
The rest of this line are random numbers from 4 different generators..
The counter reflects the number of loops...
B I N A R Y S E E D S C A N Q U A D R O
11_________________0____________________________________________
1110010110110011011010011110001111111110100110111011100101000111
0xe5b369e3fe9bb947 | 16jY7mM6wrpuAy53vKkh7QXm1JNdWK9Myu 19
continue...
1110010011000111001010001111000110100111001000001001110001000100
0xe4c728f1a7209c44 | 16jY7Ezk5et98CVBWYEigGRwWovzhEtaQ3 121
continue...
scan... 192
B I N A R Y S E E D S C A N Q U A D R O
11_________________0____________________________________________
Traceback (most recent call last):
File "11.py", line 41, in
addr = ice.privatekey_to_address(0, True, int(bina,2))
AttributeError: module 'secp256k1' has no attribute 'privatekey_to_address'
Code:
import sys
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice
print('\n B I N A R Y S E E D S C A N Q U A D R O \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
x1 = (x0+n)
a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
a1 = (a1)[2:]
for i in range(x):
a0 = str("1")
a2 = str("0")
a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a3 = (a3)[3:]#.zfill(44)
a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a4 = (a4)[3:]#.zfill(44)
a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a5 = (a5)[3:]#.zfill(44)
a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a6 = (a6)[3:]#.zfill(44)
binb = "".join(a0+a1+a2+a3)
binc = "".join(a0+a1+a2+a4)
bind = "".join(a0+a1+a2+a5)
bine = "".join(a0+a1+a2+a6)
list.append(binb)
list.append(binc)
list.append(bind)
list.append(bine)
if len(list)==x:
line_count=0
for bina in (list):
bina!='\n'
addr = ice.privatekey_to_address(0, True, int(bina,2))
line_count+=1
if addr.startswith('16jY7'): # 16jY7
ran = int(bina,2)
print('',bina, '\n')
sys.stdout.write('\r ' + hex(ran))
sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
ran = int(bina,2)
print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + hex(ran) + ' | ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print(' scan... ', str(n), end='\r')
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice
print('\n B I N A R Y S E E D S C A N Q U A D R O \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
x1 = (x0+n)
a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
a1 = (a1)[2:]
for i in range(x):
a0 = str("1")
a2 = str("0")
a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a3 = (a3)[3:]#.zfill(44)
a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a4 = (a4)[3:]#.zfill(44)
a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a5 = (a5)[3:]#.zfill(44)
a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111))
a6 = (a6)[3:]#.zfill(44)
binb = "".join(a0+a1+a2+a3)
binc = "".join(a0+a1+a2+a4)
bind = "".join(a0+a1+a2+a5)
bine = "".join(a0+a1+a2+a6)
list.append(binb)
list.append(binc)
list.append(bind)
list.append(bine)
if len(list)==x:
line_count=0
for bina in (list):
bina!='\n'
addr = ice.privatekey_to_address(0, True, int(bina,2))
line_count+=1
if addr.startswith('16jY7'): # 16jY7
ran = int(bina,2)
print('',bina, '\n')
sys.stdout.write('\r ' + hex(ran))
sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
ran = int(bina,2)
print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + hex(ran) + ' | ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print(' scan... ', str(n), end='\r')
Ca 42000 keys/s from c000000000000000 to ffffffffffffffff... The sector between 11_________________0 comprise a range of 131071 and will be processed.
The rest of this line are random numbers from 4 different generators..
The counter reflects the number of loops...
B I N A R Y S E E D S C A N Q U A D R O
11_________________0____________________________________________
1110010110110011011010011110001111111110100110111011100101000111
0xe5b369e3fe9bb947 | 16jY7mM6wrpuAy53vKkh7QXm1JNdWK9Myu 19
continue...
1110010011000111001010001111000110100111001000001001110001000100
0xe4c728f1a7209c44 | 16jY7Ezk5et98CVBWYEigGRwWovzhEtaQ3 121
continue...
scan... 192
jeniferangel79,
take a look at when the puzzle is from and what the BTC was worth at that time... surely there is a reason, security plays a big role in the crypto universe... and see what and how far the programmers get solving the puzzle is certainly an interesting aspect for future crypto projects... ^^
take a look at when the puzzle is from and what the BTC was worth at that time... surely there is a reason, security plays a big role in the crypto universe... and see what and how far the programmers get solving the puzzle is certainly an interesting aspect for future crypto projects... ^^
How about you ask Robert Langdon, I heard he is very great at something like this Well the arrangement doesn't sound good to me at this point yet will attempt with it somewhat more later. Regardless, I don't figure somebody will give out 32 BTC just to address some riddle... there should be something different that we don't have the foggiest idea or can't see.
Sherlock to protect perhaps?
Sherlock to protect perhaps?
whats the ice jolly jocker. paste code pls
with "ice" to address.. 42500 keys/s ... nice one!!
================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN==============
11%|██████ | 115508/1048576 [00:02<00:21, 42521.10it/s]
I will work on it to make it faster...I will see the 3.5 Million Keys/s Speed... in combination with such scanners..
"[faster "bit" there is a library from "ice" https://github.com/iceland2k14/secp256k1 there it is necessary to throw its libraries into the folder with the script.]"
import sys
import random
import secp256k1 as ice
from time import sleep
from tqdm import tqdm
print('\n ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN============== \n\n')
x=1048576
list=[]
print(' WAIT!....', end='\r')
while x:
b01 = random.choice("0123456789abcdef")
b02 = random.choice("0123456789abcdef")
b03 = random.choice("0123456789abcdef")
b04 = random.choice("0123456789abcdef")
b05 = random.choice("0123456789abcdef")
b06 = random.choice("0123456789abcdef")
b07 = random.choice("0123456789abcdef")
b08 = random.choice("0123456789abcdef")
b09 = random.choice("0123456789abcdef")
b10 = random.choice("0123456789abcdef")
b11 = random.choice("0123456789abcdef")
b12 = random.choice("0123456789abcdef")
b13 = random.choice("0123456789abcdef")
b14 = random.choice("0123456789abcdef")
b15 = random.choice("0123456789abcdef")
hex = (b01+b02+b03+b04+b05+b06+b07+b08+b09+b10+b11+b12+b13+b14+b15)
hex8 = '8'+ hex
list.append(hex8)
hex9 = '9'+ hex
list.append(hex9)
hexa = 'a'+ hex
list.append(hexa)
hexb = 'b'+ hex
list.append(hexb)
hexc = 'c'+ hex
list.append(hexc)
hexd = 'd'+ hex
list.append(hexd)
hexe = 'e'+ hex
list.append(hexe)
hexf = 'f'+ hex
list.append(hexf)
if len(list)==x:
line_count=0
for line0 in tqdm(list):
line0!='\n'
line_count+=1
# line = int(line0, 16)
# a = len(bin(line))-2
addr = ice.privatekey_to_address(0, True, int(line0, 16))
# sys.stdout.write('\r scanning.... [' + (line0) + '] ' + str(a) + ' bit ')
if addr.startswith('16jY7'): # 16jY7q
sys.stdout.write('\n\n ' + line0 + ' | ' + addr)
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
print('\n\n Target found!!' + line0 + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + line0 + '| ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print('\n WAIT!....\n')
================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN==============
11%|██████ | 115508/1048576 [00:02<00:21, 42521.10it/s]
I will work on it to make it faster...I will see the 3.5 Million Keys/s Speed... in combination with such scanners..
"[faster "bit" there is a library from "ice" https://github.com/iceland2k14/secp256k1 there it is necessary to throw its libraries into the folder with the script.]"
Code:
import sys
import random
import secp256k1 as ice
from time import sleep
from tqdm import tqdm
print('\n ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN============== \n\n')
x=1048576
list=[]
print(' WAIT!....', end='\r')
while x:
b01 = random.choice("0123456789abcdef")
b02 = random.choice("0123456789abcdef")
b03 = random.choice("0123456789abcdef")
b04 = random.choice("0123456789abcdef")
b05 = random.choice("0123456789abcdef")
b06 = random.choice("0123456789abcdef")
b07 = random.choice("0123456789abcdef")
b08 = random.choice("0123456789abcdef")
b09 = random.choice("0123456789abcdef")
b10 = random.choice("0123456789abcdef")
b11 = random.choice("0123456789abcdef")
b12 = random.choice("0123456789abcdef")
b13 = random.choice("0123456789abcdef")
b14 = random.choice("0123456789abcdef")
b15 = random.choice("0123456789abcdef")
hex = (b01+b02+b03+b04+b05+b06+b07+b08+b09+b10+b11+b12+b13+b14+b15)
hex8 = '8'+ hex
list.append(hex8)
hex9 = '9'+ hex
list.append(hex9)
hexa = 'a'+ hex
list.append(hexa)
hexb = 'b'+ hex
list.append(hexb)
hexc = 'c'+ hex
list.append(hexc)
hexd = 'd'+ hex
list.append(hexd)
hexe = 'e'+ hex
list.append(hexe)
hexf = 'f'+ hex
list.append(hexf)
if len(list)==x:
line_count=0
for line0 in tqdm(list):
line0!='\n'
line_count+=1
# line = int(line0, 16)
# a = len(bin(line))-2
addr = ice.privatekey_to_address(0, True, int(line0, 16))
# sys.stdout.write('\r scanning.... [' + (line0) + '] ' + str(a) + ' bit ')
if addr.startswith('16jY7'): # 16jY7q
sys.stdout.write('\n\n ' + line0 + ' | ' + addr)
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
print('\n\n Target found!!' + line0 + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + line0 + '| ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print('\n WAIT!....\n')
faster "bit" there is a library from "ice" https://github.com/iceland2k14/secp256k1 there it is necessary to throw its libraries into the folder with the script.
***
and read (with a translator) https://istina.msu.ru/profile/FilatovOV/ , https://vk.com/@fil_post-eta-statya-rvet-vse-predstavleniya-o-veroyatnostyah , https://disk.yandex.ru/i/LsEWmhs3ArM7Tw
he has studies of random events, sequences, there are formulas, I still don’t understand everything, he launches a probe there into a file with 20000000 random bits and...
pz64 ripmd160 hex to bin 1111101110010000010011001111011001100100011111010100101111110111110110101000100 1011100100110000011010011100000011101000101101011000111010000100100100010100100
11111 0 111 00 1 00000 1 00 11 00 1111 0 11 00 11 00 1 000 11111 0 1 0 1 00 1 0 111111 0 11111 0 11 0 1 0 1 000 1 00 1 0 111 00 1 00 11 00000 11 0 1 00 111 000000 111 0 1 000 1 0 11 0 1 0 11 000 111 0 1 0000 1 00 1 00 1 000 1 0 1 00 1 00
1 22
11 8
111 5
1111 1
11111 3
111111 1
1111111
11111111
0 17
00 14
000 5
0000 1
00000 2
000000 1
0000000
00000000
0, 1 - elementary events, they make waves 111 000 1111 0000... when nearby the same half-wavelength 111000 11110000...
***
and read (with a translator) https://istina.msu.ru/profile/FilatovOV/ , https://vk.com/@fil_post-eta-statya-rvet-vse-predstavleniya-o-veroyatnostyah , https://disk.yandex.ru/i/LsEWmhs3ArM7Tw
Quote
This article breaks all ideas about probabilities.
Everyone knows that it is impossible to guess the sides of a coin, but this article will show a mechanism that allows you to predict the sides of a coin, that is, you can actually guess. First, I will briefly describe the traditional way of working with probabilities, working in this way does not allow you to predict the sides of the coin. And then, in the same terse way, I will describe the way I discovered to work with probability, which allows you to predict the loss of the sides of the coin.
And so, the coin was tossed many times N and the result of its loss formed a sequence of ones and zeros. Let's determine the average length of a drop-down series of repeating identical events, for example: "00000.." or "11111.." in our large series of N flips.
It is described here: how to look at a random sequence so that the probabilities of guessing and not guessing are equal.
The traditional way to determine the average length of outliers from repeating identical events is to sequentially look through all the recorded values and accurately count the number of runs of detected lengths.
The total number of series of unit lengths: "0" and "1" will be N/4. The total number of series of length two: "00" and "11" will be N/8. The total number of series of length three: "000" and "111" will be N/16. The total number of series of length four: "0000" and "1111" will be N/32. Etc. Of course, the detected numbers of series are unlikely to be exactly equal to the calculated values, since, despite the frequency stability, there are still random probabilistic fluctuations in the actual number of events around the theoretically obtained mats.expectations. Taking into account all elementary events N of our sequence, we find that the total number of all our series ("0" + "1" + "00" + "11" + "000" + "111" + ...) is equal to N / 2 (again up to random fluctuations). Now let's solve the problem: to determine the average length of the drop-down series, for this we need to divide the number of members of the sequence N by the sum of all series N / 2. Divide N / (N/2) = 2. That is, we found that the average length of a series with the traditional way of looking at and guessing the sides of a coin is two. That is, with an average length of a consecutive series of two events, it is impossible to guess the fallout of the sides. Obviously, if the average length of a consecutive series ("0"; "1"; "00"; "11"; "000"; "111"; ...) were three events, then we would begin to guess the fallout of the sides of the coin much more often than not guessing. Let's now look at my way of getting the average event length, which is three.
It describes how to look at a random sequence so that the probabilities of guessing and not guessing become different.
In order to influence the probability, it is necessary to change the average length of a series of events falling out in a row. This is achieved by applying a well-known geometric probability to the guessing process.
The principle of geometric probability states that objects with a larger size are hit more often than objects with a smaller size. With regard to our random sequence N, this means that if we count, for example, every hundredth member of the sequence and determine the length of the series ("0"; "1"; "00"; "11"; "000"; "111"; ... ) to which it belongs, it turns out that the frequency of hits of every hundredth event in long series increased, and decreased in short series.
That is, the average length of the detected series, in the case of a geometric set of statistics, will become equal to three. And it is precisely this increase in the average length of a series from two events (with sequential counting of each event) to three events (with gaps of sufficient length between guesses) that makes it possible to guess the side of the dropped coin more often than in half of the predictions. Here, now, I have described the fundamental principle of geometric probability, in relation to changing the average length of the found series in a random binary sequence.
Everyone knows that it is impossible to guess the sides of a coin, but this article will show a mechanism that allows you to predict the sides of a coin, that is, you can actually guess. First, I will briefly describe the traditional way of working with probabilities, working in this way does not allow you to predict the sides of the coin. And then, in the same terse way, I will describe the way I discovered to work with probability, which allows you to predict the loss of the sides of the coin.
And so, the coin was tossed many times N and the result of its loss formed a sequence of ones and zeros. Let's determine the average length of a drop-down series of repeating identical events, for example: "00000.." or "11111.." in our large series of N flips.
It is described here: how to look at a random sequence so that the probabilities of guessing and not guessing are equal.
The traditional way to determine the average length of outliers from repeating identical events is to sequentially look through all the recorded values and accurately count the number of runs of detected lengths.
The total number of series of unit lengths: "0" and "1" will be N/4. The total number of series of length two: "00" and "11" will be N/8. The total number of series of length three: "000" and "111" will be N/16. The total number of series of length four: "0000" and "1111" will be N/32. Etc. Of course, the detected numbers of series are unlikely to be exactly equal to the calculated values, since, despite the frequency stability, there are still random probabilistic fluctuations in the actual number of events around the theoretically obtained mats.expectations. Taking into account all elementary events N of our sequence, we find that the total number of all our series ("0" + "1" + "00" + "11" + "000" + "111" + ...) is equal to N / 2 (again up to random fluctuations). Now let's solve the problem: to determine the average length of the drop-down series, for this we need to divide the number of members of the sequence N by the sum of all series N / 2. Divide N / (N/2) = 2. That is, we found that the average length of a series with the traditional way of looking at and guessing the sides of a coin is two. That is, with an average length of a consecutive series of two events, it is impossible to guess the fallout of the sides. Obviously, if the average length of a consecutive series ("0"; "1"; "00"; "11"; "000"; "111"; ...) were three events, then we would begin to guess the fallout of the sides of the coin much more often than not guessing. Let's now look at my way of getting the average event length, which is three.
It describes how to look at a random sequence so that the probabilities of guessing and not guessing become different.
In order to influence the probability, it is necessary to change the average length of a series of events falling out in a row. This is achieved by applying a well-known geometric probability to the guessing process.
The principle of geometric probability states that objects with a larger size are hit more often than objects with a smaller size. With regard to our random sequence N, this means that if we count, for example, every hundredth member of the sequence and determine the length of the series ("0"; "1"; "00"; "11"; "000"; "111"; ... ) to which it belongs, it turns out that the frequency of hits of every hundredth event in long series increased, and decreased in short series.
That is, the average length of the detected series, in the case of a geometric set of statistics, will become equal to three. And it is precisely this increase in the average length of a series from two events (with sequential counting of each event) to three events (with gaps of sufficient length between guesses) that makes it possible to guess the side of the dropped coin more often than in half of the predictions. Here, now, I have described the fundamental principle of geometric probability, in relation to changing the average length of the found series in a random binary sequence.
he has studies of random events, sequences, there are formulas, I still don’t understand everything, he launches a probe there into a file with 20000000 random bits and...
pz64 ripmd160 hex to bin 1111101110010000010011001111011001100100011111010100101111110111110110101000100 1011100100110000011010011100000011101000101101011000111010000100100100010100100
11111 0 111 00 1 00000 1 00 11 00 1111 0 11 00 11 00 1 000 11111 0 1 0 1 00 1 0 111111 0 11111 0 11 0 1 0 1 000 1 00 1 0 111 00 1 00 11 00000 11 0 1 00 111 000000 111 0 1 000 1 0 11 0 1 0 11 000 111 0 1 0000 1 00 1 00 1 000 1 0 1 00 1 00
1 22
11 8
111 5
1111 1
11111 3
111111 1
1111111
11111111
0 17
00 14
000 5
0000 1
00000 2
000000 1
0000000
00000000
0, 1 - elementary events, they make waves 111 000 1111 0000... when nearby the same half-wavelength 111000 11110000...
Quote
In order to influence the probability, it is necessary to change the average length of a series of events falling out in a row. This is achieved by applying a well-known geometric probability to the guessing process.
The principle of geometric probability states that objects with a larger size are hit more often than objects with a smaller size. With regard to our random sequence N, this means that if we count, for example, every hundredth member of the sequence and determine the length of the series ("0"; "1"; "00"; "11"; "000"; "111"; ... ) to which it belongs, it turns out that the frequency of hits of every hundredth event in long series increased, and decreased in short series.
what does this mean? we can run over the 2^256 range and generate these bit sets over several hashes... The principle of geometric probability states that objects with a larger size are hit more often than objects with a smaller size. With regard to our random sequence N, this means that if we count, for example, every hundredth member of the sequence and determine the length of the series ("0"; "1"; "00"; "11"; "000"; "111"; ... ) to which it belongs, it turns out that the frequency of hits of every hundredth event in long series increased, and decreased in short series.
A fast scanner that completely covers the 64-bit range with more than 12000 keys/s (depending on the CPU clock) with Intel Xeon E3-1240 V2 @ 3.40GHz (13500 keys/s)
Code:
import sys
import random
from bit import *
from time import sleep
from tqdm import tqdm
print('\n ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN============== \n\n')
x=1048576
list=[]
print(' WAIT!....', end='\r')
while x:
b01 = random.choice("0123456789abcdef")
b02 = random.choice("0123456789abcdef")
b03 = random.choice("0123456789abcdef")
b04 = random.choice("0123456789abcdef")
b05 = random.choice("0123456789abcdef")
b06 = random.choice("0123456789abcdef")
b07 = random.choice("0123456789abcdef")
b08 = random.choice("0123456789abcdef")
b09 = random.choice("0123456789abcdef")
b10 = random.choice("0123456789abcdef")
b11 = random.choice("0123456789abcdef")
b12 = random.choice("0123456789abcdef")
b13 = random.choice("0123456789abcdef")
b14 = random.choice("0123456789abcdef")
b15 = random.choice("0123456789abcdef")
hex = (b01+b02+b03+b04+b05+b06+b07+b08+b09+b10+b11+b12+b13+b14+b15)
hex8 = '8'+ hex
list.append(hex8)
hex9 = '9'+ hex
list.append(hex9)
hexa = 'a'+ hex
list.append(hexa)
hexb = 'b'+ hex
list.append(hexb)
hexc = 'c'+ hex
list.append(hexc)
hexd = 'd'+ hex
list.append(hexd)
hexe = 'e'+ hex
list.append(hexe)
hexf = 'f'+ hex
list.append(hexf)
if len(list)==x:
line_count=0
for line0 in tqdm(list):
line0!='\n'
line_count+=1
line = int(line0, 16)
a = len(bin(line))-2
key = Key.from_int(line)
addr = key.address
# sys.stdout.write('\r scanning.... [' + (line0) + '] ' + str(a) + ' bit ')
if addr.startswith('16jY7'): # 16jY7q
sys.stdout.write('\n\n ' + line0 + ' | ' + addr)
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
print('\n\n Target found!!' + line0 + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + line0 + '| ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print('\n WAIT!....\n')
import random
from bit import *
from time import sleep
from tqdm import tqdm
print('\n ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN============== \n\n')
x=1048576
list=[]
print(' WAIT!....', end='\r')
while x:
b01 = random.choice("0123456789abcdef")
b02 = random.choice("0123456789abcdef")
b03 = random.choice("0123456789abcdef")
b04 = random.choice("0123456789abcdef")
b05 = random.choice("0123456789abcdef")
b06 = random.choice("0123456789abcdef")
b07 = random.choice("0123456789abcdef")
b08 = random.choice("0123456789abcdef")
b09 = random.choice("0123456789abcdef")
b10 = random.choice("0123456789abcdef")
b11 = random.choice("0123456789abcdef")
b12 = random.choice("0123456789abcdef")
b13 = random.choice("0123456789abcdef")
b14 = random.choice("0123456789abcdef")
b15 = random.choice("0123456789abcdef")
hex = (b01+b02+b03+b04+b05+b06+b07+b08+b09+b10+b11+b12+b13+b14+b15)
hex8 = '8'+ hex
list.append(hex8)
hex9 = '9'+ hex
list.append(hex9)
hexa = 'a'+ hex
list.append(hexa)
hexb = 'b'+ hex
list.append(hexb)
hexc = 'c'+ hex
list.append(hexc)
hexd = 'd'+ hex
list.append(hexd)
hexe = 'e'+ hex
list.append(hexe)
hexf = 'f'+ hex
list.append(hexf)
if len(list)==x:
line_count=0
for line0 in tqdm(list):
line0!='\n'
line_count+=1
line = int(line0, 16)
a = len(bin(line))-2
key = Key.from_int(line)
addr = key.address
# sys.stdout.write('\r scanning.... [' + (line0) + '] ' + str(a) + ' bit ')
if addr.startswith('16jY7'): # 16jY7q
sys.stdout.write('\n\n ' + line0 + ' | ' + addr)
sleep(1)
sys.stdout.write('\n\n continue...\n\n')
sleep(1)
if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
print('\n\n Target found!!' + line0 + ' \n ' + addr,'\n')
file=open(u"16j.Target.Info.txt","a")
file.write('\n ' + line0 + '| ' + addr)
file.close()
sleep(2)
wait = input("Press Enter to Exit.")
sleep(1)
exit()
if line_count==x:
list.clear()
if len(list)==0:
print('\n WAIT!....\n')
Jump to: