Let's see if I understand
possibility #1you generated
1000m of keys with intervals of 1m between each 1
1000095 to
10000000951000095
1000000095in
hex 00000000000000000000000000000000000000000000000000000000000f429f
000000000000000000000000000000000000000000000000000000003b9aca5fyou put 1btc in any of them
you lost the private key
You know the address, the public key, and the range so finding it will only take minutes.
if the range is in hex
use
download repo
https://github.com/WanderingPhilosopher/KeyHuntCudaClientopen x64 folder
open console in folder
paste
with GPUKeyHunt-Cuda.exe -t 0 -g --gpui 0 --gpux 256,256 -m xpoint --coin BTC --range "your range here. start:end" "your public here whitout first 2 ch"
exampleKeyHunt-Cuda.exe -t 0 -g --gpui 0 --gpux 256,256 -m xpoint --coin BTC --range 8000000000:ffffffffff a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4
with CPUKeyHunt-Cuda.exe -t "HERE CPU CORES TO USE" --gpui 0 --gpux 256,256 -m xpoint --coin BTC --range "your range heree. start:end" "your public here whitout first 2"
exampleKeyHunt-Cuda.exe -t 4 --gpui 0 --gpux 256,256 -m xpoint --coin BTC --range 8000000000:ffffffffff a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4
testet with my 4 cpu cores
1mkey/s = 1000mKeys in 1000 sec or 17 minutes.
If range is Decimal
example
1000000 to
20000000in python
decimal to hex
start =1000000000
h = hex(start)[2: ]
print('hex :', h)
end =2000000000
h = hex(end)[2: ]
print('hex :', h)
use hex in keyhuntcuda
to generate the ranges of
1000000 in decimals you only add 1m x times
if you want to save all pubkey and privkey in ranges of every 1m
python modulesrandom
bitcoin
pip install bitcoin
for compressed addrimport bitcoin as bit
import random
#edit range_start
range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
add= str(N) +'000000'
result= int(add)
sum= int(result + range_start)
b = hex(sum)[2:]
c = str.format(b)
pk= c.zfill(64)
public_key = bit.privkey_to_pubkey(pk)
public_key_compressed = bit.compress(public_key)
data = open("found.txt","a")
data.write(str(public_key_compressed)+"\n"+ str(pk)+"\n")
data.close()
import bitcoin as bit
import random
#edit range_start
range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
add= str(N) +'000000'
result= int(add)
sum= int(result + range_start)
b = hex(sum)[2:]
c = str.format(b)
pk= c.zfill(64)
public_key = bit.privkey_to_pubkey(pk)
data = open("found.txt","a")
data.write(str(public_key)+"\n"+ str(pk)+"\n")
data.close()
if you know the public key and you want to save it
for compressed addrimport bitcoin as bit
import random
#edit range_start
range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
add= str(N) +'000000'
result= int(add)
sum= int(result + range_start)
b = hex(sum)[2:]
c = str.format(b)
pk= c.zfill(64)
public_key = bit.privkey_to_pubkey(pk)
public_key_compressed = bit.compress(public_key)
target = "here your public key"
if public_key_compressed in target:
print("address found")
data = open("found.txt","a")
data.write(str(pk)+"\n"+ str(public_key_compressed)+"\n")
data.close()
import bitcoin as bit
import random
#edit range_start
range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
add= str(N) +'000000'
result= int(add)
sum= int(result + range_start)
b = hex(sum)[2:]
c = str.format(b)
pk= c.zfill(64)
public_key = bit.privkey_to_pubkey(pk)
target = "here your public key"
if public_key in target:
print("address found")
data = open("found.txt","a")
data.write(str(pk)+"\n"+ str(public_key)+"\n")
data.close()
you take Hex(only numbers)
example1000000 in
decimal is
10000001000000 in
hex is
f4240range
1000000- 1000000000 in hex is
0000000000000000000000000000000000000000000000000000000001000000
0000000000000000000000000000000000000000000000000000001000000000
this increase your search range
use pythonif you want to save all public keys and private keys in ranges of every 1m
for compressed addrimport bitcoin as bit
import random
#edit range_start
range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
add= str(N) +'000000'
result= int(add)
sum= str(result + range_start)
pk= sum.zfill(64)
public_key = bit.privkey_to_pubkey(pk)
public_key_compressed = bit.compress(public_key)
data = open("found.txt","a")
data.write(str(public_key_compressed)+"\n"+ str(pk)+"\n")
data.close()
import bitcoin as bit
import random
#edit range_start
range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
add= str(N) +'000000'
result= int(add)
sum= str(result + range_start)
pk= sum.zfill(64)
public_key = bit.privkey_to_pubkey(pk)
data = open("found.txt","a")
data.write(str(public_key)+"\n"+ str(pk)+"\n")
data.close()
import bitcoin as bit
import random
#edit range_start
range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
add= str(N) +'000000'
result= int(add)
sum= str(result + range_start)
pk= sum.zfill(64)
public_key = bit.privkey_to_pubkey(pk)
public_key_compressed = bit.compress(public_key)
target = "here your public key"
if public_key_compressed in target:
print("address found")
data = open("found.txt","a")
data.write(str(pk)+"\n"+ str(public_key_compressed)+"\n")
data.close()
import bitcoin as bit
import random
#edit range_start
range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
add= str(N) +'000000'
result= int(add)
sum= str(result + range_start)
pk= sum.zfill(64)
public_key = bit.privkey_to_pubkey(pk))
target = "here your public key"
if public_key in target:
print("address found")
data = open("found.txt","a")
data.write(str(pk)+"\n"+ str(public_key)+"\n")
data.close()
in case you are an honest person.
bc1qtfhwwgf5pmq99f5x8hwvvklepzxumdxgrmya8k 
problem is, his quantum computer will probably not have any error correction so the results will be wildly off. 
