Bitcoin puzzle transaction ~32 BTC prize to who solves it

[itod]

Alright, this question might sound stupid but pardon me, i need to educate myself about this but I'm not able to find any piece of info on internet that can put this confusion at ease. So when a new block is mined it says COINBASE (Newly Generated Coins) so from where are these new coins getting generated? if the definition of poW is just authenticating a transaction how is authenticating a transaction generating new coins??. what is a coin? what data does it hold?  the next question is what is actually inside a private key..?? when we say a coin has anyone in here read the data in the coin? what is a Bitcoin (i know its a digital currency)  but i really wanna know what bitcoin truly is  is it just a number associated with the private key..?? (what i mean by it is, lets say 1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH has 1btc, where is that 1 btc..?? how is a value given..? from where is it generated? what is coinbase? when i recive 1btc in my wallet what am i receiving..?

would greatly appreciate an answer
thanks

You have some reading to do, can start here:
https://en.bitcoinwiki.org/wiki/Bitcoin_FAQ_(Frequently_Asked_Questions)

hey i was wondering if you any fastest miners or asics ..?

Is this a bot? Question has no meaning.

[asicprince]

is it faster if we use brute force attack on addresses in the puzzle by tools like bitbruteforce, plutus, btcbf... I mean these tools are generate random wallets (in 2^256 range) then check a list for matching an wallet with balance, which chance to success is much lower than 0. If now we use these tools but control the range to generate wallet only in 2^64 or 2^71-74... to find matching address in puzzle (the address list still can contain funded addresses).
I think this method will give more chance than kangaroo/bsgs or bitcrack, while solving puzzle they can find some funded addresses but still ignore them because it's not match with their target - addresses in puzzle only

[Evillo]

Hello guys, first time writing here but have been reading a lot in the forum .. i was just thinking the puzzle #64 could be in the range 8 or 9 other than a, b , c , d , e ,f .. and nobody is looking in 8 or 9 and maybe that's why no one could still find the puzzle lol .. do we have any record of these ranges being scanned or not? Like in pool scanning or so?

[Feron]

is it faster if we use brute force attack on addresses in the puzzle by tools like bitbruteforce, plutus, btcbf... I mean these tools are generate random wallets (in 2^256 range) then check a list for matching an wallet with balance, which chance to success is much lower than 0. If now we use these tools but control the range to generate wallet only in 2^64 or 2^71-74... to find matching address in puzzle (the address list still can contain funded addresses).
I think this method will give more chance than kangaroo/bsgs or bitcrack, while solving puzzle they can find some funded addresses but still ignore them because it's not match with their target - addresses in puzzle only

those listed codes are slow in python like turtle  speed
example:https://github.com/Xefrok/BitBruteForce-Wallet

Code:

import time
import datetime as dt
import smtplib
import os
import multiprocessing
from multiprocessing import Pool
import binascii, hashlib, base58, ecdsa
import pandas as pd
from tqdm import tqdm
def ripemd160(x):
    d = hashlib.new('ripemd160')
    d.update(x)
    return d

r = 0
cores=2


def seek(r, df_handler):
	global num_threads
	LOG_EVERY_N = 1000
	start_time = dt.datetime.today().timestamp()
	i = 0
	print("Core " + str(r) +":  Searching Private Key..")
	for xxxxx in tqdm(range(1000000)):
		i=i+1
		# generate private key , uncompressed WIF starts with "5"
		priv_key = os.urandom(32)
		fullkey = '80' + binascii.hexlify(priv_key).decode()
		sha256a = hashlib.sha256(binascii.unhexlify(fullkey)).hexdigest()
		sha256b = hashlib.sha256(binascii.unhexlify(sha256a)).hexdigest()
		WIF = base58.b58encode(binascii.unhexlify(fullkey+sha256b[:8]))

		# get public key , uncompressed address starts with "1"
		sk = ecdsa.SigningKey.from_string(priv_key, curve=ecdsa.SECP256k1)
		vk = sk.get_verifying_key()
		publ_key = '04' + binascii.hexlify(vk.to_string()).decode()
		hash160 = ripemd160(hashlib.sha256(binascii.unhexlify(publ_key)).digest()).digest()
		publ_addr_a = b"\x00" + hash160
		checksum = hashlib.sha256(hashlib.sha256(publ_addr_a).digest()).digest()[:4]
		publ_addr_b = base58.b58encode(publ_addr_a + checksum)
		priv = WIF.decode()
		pub = publ_addr_b.decode()
		time_diff = dt.datetime.today().timestamp() - start_time
		if (i % LOG_EVERY_N) == 0:
			print('Core :'+str(r)+" K/s = "+ str(i / time_diff))
		#print ('Worker '+str(r)+':'+ str(i) + '.-  # '+pub + ' # -------- # '+ priv+' # ')
		pub = pub + '\n'
		filename = 'bit.txt'
		with open(filename) as f:
			for line in f:
				if pub in line:
					msg = "\nPublic: " + str(pub) + " ---- Private: " + str(priv) + "YEI"
					text = msg
					#UNCOMMENT IF 2FA from gmail is activated, or risk missing your winning ticket;)
					#server = smtplib.SMTP("smtp.gmail.com", 587)
					#server.ehlo()
					#server.starttls()
					#server.login("example@gmail.com", "password")
					#fromaddr = "example@gmail.com"
					#toaddr = "example@gmail.com"
					#server.sendmail(fromaddr, toaddr, text)
					print(text)
					with open('Wallets.txt','a') as f:
						f.write(priv)
						f.write('     ')
						f.write(pub)
						f.write('\n')
						f.close()
					time.sleep(30)
					print ('WINNER WINNER CHICKEN DINNER!!! ---- ' +dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), pub, priv)
					break
					



contador=0
if __name__ == '__main__':
	jobs = []
	df_handler = pd.read_csv(open('bit.txt', 'r'))
	for r in range(cores):
		p = multiprocessing.Process(target=seek, args=(r,df_handler))
		jobs.append(p)
		p.start()

the fastest python library is here: https://github.com/iceland2k14/secp256k1

[asicprince]

is it faster if we use brute force attack on addresses in the puzzle by tools like bitbruteforce, plutus, btcbf... I mean these tools are generate random wallets (in 2^256 range) then check a list for matching an wallet with balance, which chance to success is much lower than 0. If now we use these tools but control the range to generate wallet only in 2^64 or 2^71-74... to find matching address in puzzle (the address list still can contain funded addresses).
I think this method will give more chance than kangaroo/bsgs or bitcrack, while solving puzzle they can find some funded addresses but still ignore them because it's not match with their target - addresses in puzzle only

those listed codes are slow in python like turtle  speed
example:https://github.com/Xefrok/BitBruteForce-Wallet

Code:

import time
import datetime as dt
import smtplib
import os
import multiprocessing
from multiprocessing import Pool
import binascii, hashlib, base58, ecdsa
import pandas as pd
from tqdm import tqdm
def ripemd160(x):
    d = hashlib.new('ripemd160')
    d.update(x)
    return d

r = 0
cores=2


def seek(r, df_handler):
	global num_threads
	LOG_EVERY_N = 1000
	start_time = dt.datetime.today().timestamp()
	i = 0
	print("Core " + str(r) +":  Searching Private Key..")
	for xxxxx in tqdm(range(1000000)):
		i=i+1
		# generate private key , uncompressed WIF starts with "5"
		priv_key = os.urandom(32)
		fullkey = '80' + binascii.hexlify(priv_key).decode()
		sha256a = hashlib.sha256(binascii.unhexlify(fullkey)).hexdigest()
		sha256b = hashlib.sha256(binascii.unhexlify(sha256a)).hexdigest()
		WIF = base58.b58encode(binascii.unhexlify(fullkey+sha256b[:8]))

		# get public key , uncompressed address starts with "1"
		sk = ecdsa.SigningKey.from_string(priv_key, curve=ecdsa.SECP256k1)
		vk = sk.get_verifying_key()
		publ_key = '04' + binascii.hexlify(vk.to_string()).decode()
		hash160 = ripemd160(hashlib.sha256(binascii.unhexlify(publ_key)).digest()).digest()
		publ_addr_a = b"\x00" + hash160
		checksum = hashlib.sha256(hashlib.sha256(publ_addr_a).digest()).digest()[:4]
		publ_addr_b = base58.b58encode(publ_addr_a + checksum)
		priv = WIF.decode()
		pub = publ_addr_b.decode()
		time_diff = dt.datetime.today().timestamp() - start_time
		if (i % LOG_EVERY_N) == 0:
			print('Core :'+str(r)+" K/s = "+ str(i / time_diff))
		#print ('Worker '+str(r)+':'+ str(i) + '.-  # '+pub + ' # -------- # '+ priv+' # ')
		pub = pub + '\n'
		filename = 'bit.txt'
		with open(filename) as f:
			for line in f:
				if pub in line:
					msg = "\nPublic: " + str(pub) + " ---- Private: " + str(priv) + "YEI"
					text = msg
					#UNCOMMENT IF 2FA from gmail is activated, or risk missing your winning ticket;)
					#server = smtplib.SMTP("smtp.gmail.com", 587)
					#server.ehlo()
					#server.starttls()
					#server.login("example@gmail.com", "password")
					#fromaddr = "example@gmail.com"
					#toaddr = "example@gmail.com"
					#server.sendmail(fromaddr, toaddr, text)
					print(text)
					with open('Wallets.txt','a') as f:
						f.write(priv)
						f.write('     ')
						f.write(pub)
						f.write('\n')
						f.close()
					time.sleep(30)
					print ('WINNER WINNER CHICKEN DINNER!!! ---- ' +dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), pub, priv)
					break
					



contador=0
if __name__ == '__main__':
	jobs = []
	df_handler = pd.read_csv(open('bit.txt', 'r'))
	for r in range(cores):
		p = multiprocessing.Process(target=seek, args=(r,df_handler))
		jobs.append(p)
		p.start()

the fastest python library is here: https://github.com/iceland2k14/secp256k1

thanks for your suggestion. i know that these tools are slow, but i'm talking about other method to do. btw iceland2k14/secp256k1 code is for running on window only, i wanna try my luck with my macbook pro. can you pls suggest other python code? sr but i am not a coder or dev...

[Evillo]

We need a strong random search repo .. coz i think searching in ranges is useless (including random range search).. pure random search is  the only way .. the only thing that "might" beat extreme randomness is randomness itself .. think about it, you might open a random search bat file to search for the easiest puzzle and find it immediately .. or you can open it and it keeps running for centuries without luck .. but at least you know you could get lucky with randomness ..on the other hand, searching in ranges GUARANTEES you'll stay stuck for a long while especially if the puzzle prv key turns out to be located way far in the range .. i tried keyhunt for cpu but it's too slow .. also tried random bitcrack search but i hate the fact that it creates sample points to start searching from .. it's exactly like random range search not a pure random one .. could not find any software that utilizes gpu for absolute random search

[WanderingPhilospher]

We need a strong random search repo .. coz i think searching in ranges is useless (including random range search).. pure random search is  the only way .. the only thing that "might" beat extreme randomness is randomness itself .. think about it, you might open a random search bat file to search for the easiest puzzle and find it immediately .. or you can open it and it keeps running for centuries without luck .. but at least you know you could get lucky with randomness ..on the other hand, searching in ranges GUARANTEES you'll stay stuck for a long while especially if the puzzle prv key turns out to be located way far in the range .. i tried keyhunt for cpu but it's too slow .. also tried random bitcrack search but i hate the fact that it creates sample points to start searching from .. it's exactly like random range search not a pure random one .. could not find any software that utilizes gpu for absolute random search

For GPU, it would be slower than normal search. Example, a sequential search for keyhunt will be much faster than a random search. I have modified keyhunt and vansearch to do random search, but it's still somewhat sequential. If you have 1 million threads on a GPU each one has to rekey, well key 1 is random and then starts going sequential until last thread sets it's random key, and then the whole process starts over. I will dig up old files (at some point) and look at the code again. Granted the 1 millionth key takes less than 5 seconds, but during those 5 seconds, the other keys are in sequential mode.
But at the same time, if you are searching random ranges, you have the same chance of finding the key immediately. And that's what most pools are designed to do; create all ranges in the 64 bit range, and assign those randomly.

[Feron]

funny coincidence 63 puzzle 7cce5efd : accf6808

Code:

from tqdm import tqdm
import secp256k1 as ice
for x in tqdm(range(4000000)):
 xx = str(x)
 ke = ice.checksum(xx).hex()
 #cc = ice.privatekey_loop_h160(10,0,True,xx).hex()
 if (ke).endswith("7cce5efd"):
  print(xx,x)
 if "7cce5efd" in (ke): 
  f=open("kkk.txt","a")
  f.write(str(xx)+"-"+(ke)+"\n")
  f.close()

scanner for this method

Code:

import secp256k1 as ice
for xa in range(400000):
 for xb in range(400000):
  x1 = str(xa)
  x2 = str(xb)
  k1 = ice.checksum(x1).hex()
  k2 = ice.checksum(x2).hex()
  xx = int(k1+k2,16)
  ke = ice.privatekey_loop_h160(1,0,True,xx).hex()
  if (ke).endswith("48a4"):
   print(xx,k1+k2,ke)
  if "3ee4133d991f52fdf6a25c9834e0745ac74248a4" in (ke):
   f=open("von.txt","a")
   f.write(str(xx)+"-"+(ke)+"\n")
   f.close()

[Evillo]

We need a strong random search repo .. coz i think searching in ranges is useless (including random range search).. pure random search is  the only way .. the only thing that "might" beat extreme randomness is randomness itself .. think about it, you might open a random search bat file to search for the easiest puzzle and find it immediately .. or you can open it and it keeps running for centuries without luck .. but at least you know you could get lucky with randomness ..on the other hand, searching in ranges GUARANTEES you'll stay stuck for a long while especially if the puzzle prv key turns out to be located way far in the range .. i tried keyhunt for cpu but it's too slow .. also tried random bitcrack search but i hate the fact that it creates sample points to start searching from .. it's exactly like random range search not a pure random one .. could not find any software that utilizes gpu for absolute random search

For GPU, it would be slower than normal search. Example, a sequential search for keyhunt will be much faster than a random search. I have modified keyhunt and vansearch to do random search, but it's still somewhat sequential. If you have 1 million threads on a GPU each one has to rekey, well key 1 is random and then starts going sequential until last thread sets it's random key, and then the whole process starts over. I will dig up old files (at some point) and look at the code again. Granted the 1 millionth key takes less than 5 seconds, but during those 5 seconds, the other keys are in sequential mode.
But at the same time, if you are searching random ranges, you have the same chance of finding the key immediately. And that's what most pools are designed to do; create all ranges in the 64 bit range, and assign those randomly.

Yeah thanks for pointing that out .. i overlooked the price you must pay for absolute randomness .. Rotor-cuda for example shows it very clearly when you run it with a setting of rekeying every 1b key .. counter shows a drop in speed of over 100m key/s during rekey before it climbs back up again after rekey is done ..imagine the rekey after every single key .. overhead would be devastating .. so i guess we have to stick to random ranges after all

[POD5]

funny coincidence 63 puzzle 7cce5efd : accf6808

Code:

from tqdm import tqdm
import secp256k1 as ice
for x in tqdm(range(4000000)):
 xx = str(x)
 ke = ice.checksum(xx).hex()
 #cc = ice.privatekey_loop_h160(10,0,True,xx).hex()
 if (ke).endswith("7cce5efd"):
  print(xx,x)
 if "7cce5efd" in (ke): 
  f=open("kkk.txt","a")
  f.write(str(xx)+"-"+(ke)+"\n")
  f.close()

scanner for this method

Code:

import secp256k1 as ice
for xa in range(400000):
 for xb in range(400000):
  x1 = str(xa)
  x2 = str(xb)
  k1 = ice.checksum(x1).hex()
  k2 = ice.checksum(x2).hex()
  xx = int(k1+k2,16)
  ke = ice.privatekey_loop_h160(1,0,True,xx).hex()
  if (ke).endswith("48a4"):
   print(xx,k1+k2,ke)
  if "3ee4133d991f52fdf6a25c9834e0745ac74248a4" in (ke):
   f=open("von.txt","a")
   f.write(str(xx)+"-"+(ke)+"\n")
   f.close()

I like your way of coding.
But where is the coincidence and why do you choose 400000?
Hmm, ok, I think I got it... Not! 

[Jolly Jocker]

BTC FLOAT SCAN #64

another way of scanning..

Code:

import time
import random
import secp256k1 as ice
from time import sleep

t = time.ctime()
print('',t)

print('\n\n * BTC FLOAT SCAN #64 *\n')
print('\n |=========CURRENT===LINE=========||=====CNT====||=FLOAT=||=LOOP=|\n\n')
sleep(1)
print(' scanning...',end='\r')

def range_with_floats(start, stop, step):
    while stop > start:
        yield start
        start += step
        
a=9223372036854775807
b=9223372036854775808
#=========================================     
c = 1000000
d = 3846
group_size = c
#========================================= 
e = 0.0000031115691002
f = 1.0000000000000000
g = 0.000001
#========================================= 
total=0
loop=0
for x in range_with_floats(e, f, g):
    loop += 1
    for i in range(d):
        x += 0.00026
        xx = x
        x1 = int(a * x + b)
        key_int = x1 
        P = ice.scalar_multiplication(key_int)
        current_pvk = key_int + 1
          
        Pv = ice.point_sequential_increment(group_size, P)
              
        for t in range(group_size):
            this_btc = ice.pubkey_to_address(0, True, Pv[t*65:t*65+65])
            total+=1
            if this_btc.startswith('16jY7'): # 16jY7q
                print(' ',hex(current_pvk+t)[2:],(this_btc)[:12] + '... ',str(total).zfill(12),'','{0:.5f}'.format(xx),'',str(loop).zfill(6),end='\r')
                
                if this_btc == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
                    file=open(u"BTC.Target.Info.txt","a")
                    file.write('\n ' + this_btc + ' | ' + hex(current_pvk+t))
                    file.close()
                    sleep(1)
                    exit()

        P = Pv[-65:]
        current_pvk += group_size

[cookiebro]

BTC FLOAT SCAN #64

another way of scanning..

Code:

import time
import random
import secp256k1 as ice
from time import sleep

t = time.ctime()
print('',t)

print('\n\n * BTC FLOAT SCAN #64 *\n')
print('\n |=========CURRENT===LINE=========||=====CNT====||=FLOAT=||=LOOP=|\n\n')
sleep(1)
print(' scanning...',end='\r')

def range_with_floats(start, stop, step):
    while stop > start:
        yield start
        start += step
        
a=9223372036854775807
b=9223372036854775808
#=========================================     
c = 1000000
d = 3846
group_size = c
#========================================= 
e = 0.0000031115691002
f = 1.0000000000000000
g = 0.000001
#========================================= 
total=0
loop=0
for x in range_with_floats(e, f, g):
    loop += 1
    for i in range(d):
        x += 0.00026
        xx = x
        x1 = int(a * x + b)
        key_int = x1 
        P = ice.scalar_multiplication(key_int)
        current_pvk = key_int + 1
          
        Pv = ice.point_sequential_increment(group_size, P)
              
        for t in range(group_size):
            this_btc = ice.pubkey_to_address(0, True, Pv[t*65:t*65+65])
            total+=1
            if this_btc.startswith('16jY7'): # 16jY7q
                print(' ',hex(current_pvk+t)[2:],(this_btc)[:12] + '... ',str(total).zfill(12),'','{0:.5f}'.format(xx),'',str(loop).zfill(6),end='\r')
                
                if this_btc == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
                    file=open(u"BTC.Target.Info.txt","a")
                    file.write('\n ' + this_btc + ' | ' + hex(current_pvk+t))
                    file.close()
                    sleep(1)
                    exit()

        P = Pv[-65:]
        current_pvk += group_size

Sorry, what exactly is happening in this?

[Jolly Jocker]

Sorry, what exactly is happening in this?

Another form of random with "FLOAT"

That's actually quite simple.. the 64-bit area is divided into decimal places. From 0.000001 to 1.000000 captures the entire range.. The size of the steps is set using the decimal places. This can be varied, the more decimal places, the smaller/finer the steps...

[iparktur]

Sorry, what exactly is happening in this?

Another form of random with "FLOAT"

That's actually quite simple.. the 64-bit area is divided into decimal places. From 0.000001 to 1.000000 captures the entire range.. The size of the steps is set using the decimal places. This can be varied, the more decimal places, the smaller/finer the steps...

Will it work with Python?

If "NO" - perhaps there is an option for working with Python?

[Jolly Jocker]

Will it work with Python?

If "NO" - perhaps there is an option for working with Python?

This code is programmed in Python 3.x ...

You need this for this code as import.. https://github.com/iceland2k14/secp256k1

[Evillo]

Puzzle #64 is beating everyone .. this tells us that even if it gets solved, moving on to puzzle #66 and trying to solve it is practically impossible .. let alone trying to crack 67, 68 69 etc..

This is it guys, only 64 and 120 are to be cracked (hardly) .. every other puzzle is there to stay unsolved forever.. unless owner decides to reveal public keys of all the small ranges, which will not happen, as it would defeat the purpose of the puzzle

[GR Sasa]

Puzzle 64 beating everyone? No! Just wait for GR Sasa's GPU'S Army to come. They will go far beyond 64 bits.

[NotATether]

Puzzle 64 beating everyone? No! Just wait for GR Sasa's GPU'S Army to come. They will go far beyond 64 bits.

And exactly how many GPUs does your army have, and what models are they?

Without a Bitcrack build with major improvements, you will need an extraordinary number of [NVIDIA] GPUs to even get 20 miles within #64's gate.

There are loop unrolls that can be made in the SHA256 and RIPEMD160 modules, because the number of blocks as input to these hash functions is constant.

[Evillo]

Puzzle 64 beating everyone? No! Just wait for GR Sasa's GPU'S Army to come. They will go far beyond 64 bits.

Nice! However, i find it a little bit unbelievable that you only waited all those years to provide such a huge claim as a response to a random post on the puzzle thread .. i wonder how much longer it might take until someone else comes here and claim they invented quantum computers that will beat the entire puzzle range.

Btw, it's already written some where on github that you need 256 TESLA V100 to cover puzzle #120 (same #64 difficulty if using kangaroo) .. and even then, you would need two months to solve it .. good luck to your army 😘

[Evillo]

Reading all the way back from first page .. it was amusing to see the development of this topic .. people were all about trying to solve "a math formula" in order to predict all puzzle bits (puzzle creator had it all the way until 256 bits then changed his mind after remembering that trying to crack anything over 160 bits is a fantasy) .. it was funny most ppl back then thought that cracking even 50 bits would take "decades" .. until the almighty bitcrack and kangaroo came into existence .. i wonder how this thread would look like in 10 years from now