Bitcoin puzzle transaction ~32 BTC prize to who solves it

[digaran]

for those still doing puzzle:) here is WIF 1-65 compressed and uncompressed hope this helps. if so tip me up.

i give up now:(

Why do you have so many uncompressed private keys? Don't you know puzzle transactions use compressed addresses only? Searching for unc addresses and even storing them is a waste of time.

[crewchill]

Code:

import string
import random
import time
import numpy as np
import pyopencl as cl  
import math    
# You can input here
length = 17  #hex length for 66 
num = 1000000 
randStr = "abcdefghijklmnopqrstuvwxyz0123456789"

# end of Input


def randomwords(size, chars):
	return ''.join(random.choice(chars) for _ in range(size))

def cpu_gen(length, num, randStr):
	str_list=[]
	cpu_start_time = time.time()  # Get the CPU start time
	for i in range(num):
		str_list.append(randomwords(length, randStr))
	cpu_end_time = time.time()  # Get the CPU end time
	timeGap = cpu_end_time - cpu_start_time
	print("CPU Time: {0} s".format(timeGap))
	print("****************************************************")
	print("Random Strings gnerated by CPU")
	#print(str_list)
	return timeGap

def gpu_gen(length, num, randStr):
	#define random basic letters
	# radom base length
	totChar = length * num
	randomIndex = len(randStr)
	# parameters of random generation function
	# right_index = np.array.randint(randomIndex, size= totChar)
	right_index = np.empty(totChar, dtype=str)
	ranss = np.array((randStr,))

	rand_seed = math.floor(time.time()) % 20
	# define the contect to use gpu
	ctx = cl.create_some_context(0)
	queue = cl.CommandQueue(ctx)
	# define flag of the opencl
	mf = cl.mem_flags

	rand_buff_1 = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=right_index)
	rand_str = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=ranss)
	program = cl.Program(ctx, """
	int mpow(int n, int p){
		int s =1;
		for(int i=1; i<=p; ++i){
			s = s * n;
		}
		return s;
	}
	int myRand(int next){
		next = ((next * (next % 3) )/50)% 100;
		return next;
	}
	int mabs(int a){
		if (a<0){
			a = 0-a;
		}
		return a;
	}
	int myRandInRange(int next, int min, int max){
		int temp;
		if (max < min){
			temp = max;
			max = min;
			min = temp;
		}
		return myRand(next) % (max + 1 - min) + min;
	}
	__kernel void RandGen(
	    __global int *rand_out_buff, __global char *ss, int rand_buff, int seed_buff)
	{
	  
	  int gid = get_global_id(0);
	 
	  int temp = mpow(gid, seed_buff) + seed_buff % (gid+1);
	  
	  int input = myRandInRange(temp, gid * seed_buff, gid * (gid % seed_buff)) + seed_buff;
	  input  = mabs(input);
	  rand_out_buff[gid] =ss[(input % rand_buff)*4];
	}
	""").build()

	rand_out_buff = cl.Buffer(ctx, mf.WRITE_ONLY, right_index.nbytes)
	gpu_start_time = time.time()
	event = program.RandGen(queue, right_index.shape, None, rand_out_buff, rand_str, np.int32(randomIndex), np.int32(rand_seed))
	event.wait()
	rand_list = np.empty_like(right_index)
	cl.enqueue_copy(queue, rand_list, rand_out_buff)
	gpu_end_time = time.time()  # Get the GPU end time
	timeGap = gpu_end_time - gpu_start_time
	print("GPU Time: {0} s".format(timeGap))
	for i in range(totChar):
		if i>1 and i % length==0:print('' ,end='')
		#print(rand_list[i], end='')
	#print('')
	print("****************************************************")
	print("Random Strings gnerated by GPU")
	return timeGap

cpu_time = cpu_gen(length, num, randStr)
gpu_time = gpu_gen(length, num, randStr)
print("****************************************************")
print("CPU and GPU execution time comparison")
print("CPU Time: {0} s".format(cpu_time))
print("GPU Time: {0} s".format(gpu_time))

 compile this random generator with  ice.secp256k1 to increase speed.

[citb0in]

Code:

[...]
num = 50000000 
[...]
#cpu_time = cpu_gen(length, num, randStr)
gpu_time = gpu_gen(length, num, randStr)
print("****************************************************")
print("CPU and GPU execution time comparison")
#print("CPU Time: {0} s".format(cpu_time))
print("GPU Time: {0} s".format(gpu_time))

I was curious to see if and how fast the GPU part is done. So I disabled the CPU part in your code and raised num to 50 million. Before starting I opened my Nvidia System app to monitor the load of my GPU. After about 1.5 sec my Nvidia System Monitor showed

Used Dedicated Memory: 3531 MB (43%)
GPU Utilization: 0%

that means that data was loaded into the dedicated memory, but GPU utilization remains during the complete run at 0% which is unusual. Whenever I run other tools like VanitySearch, BitCrack, KeyHunt-Cuda, etc. GPU utilization is at 100%. I doubt that everything is running at optimum speed inside the GPU part.

Also, when measuring the execution time it takes 39sec. and not only 0.9sec as stated by the program.

$ time python3 crewchill.py
GPU Time: 0.9311995506286621 s
****************************************************
Random Strings gnerated by GPU
****************************************************
CPU and GPU execution time comparison
GPU Time: 0.9311995506286621 s

real   0m39,594s
user   0m38,058s
sys   0m3,153s

[crewchill]

Code:

[...]
num = 50000000 
[...]
#cpu_time = cpu_gen(length, num, randStr)
gpu_time = gpu_gen(length, num, randStr)
print("****************************************************")
print("CPU and GPU execution time comparison")
#print("CPU Time: {0} s".format(cpu_time))
print("GPU Time: {0} s".format(gpu_time))

I was curious to see if and how fast the GPU part is done. So I disabled the CPU part in your code and raised num to 50 million. Before starting I opened my Nvidia System app to monitor the load of my GPU. After about 1.5 sec my Nvidia System Monitor showed

Used Dedicated Memory: 3531 MB (43%)
GPU Utilization: 0%

that means that data was loaded into the dedicated memory, but GPU utilization remains during the complete run at 0% which is unusual. Whenever I run other tools like VanitySearch, BitCrack, KeyHunt-Cuda, etc. GPU utilization is at 100%. I doubt that everything is running at optimum speed inside the GPU part.

Also, when measuring the execution time it takes 39sec. and not only 0.9sec as stated by the program.

$ time python3 crewchill.py
GPU Time: 0.9311995506286621 s
****************************************************
Random Strings gnerated by GPU
****************************************************
CPU and GPU execution time comparison
GPU Time: 0.9311995506286621 s

real   0m39,594s
user   0m38,058s
sys   0m3,153s

0.9 seconds is too fast to activate gpu.

39s because you print space.

Code:

for i in range(totChar):
		if i>1 and i % length==0:print('' ,end='')    <=hide this print and try again 

[citb0in]

commenting the if-line results in 2.6 seconds, that helped. However I don't see any GPU utilization. I tried raising num to 50 million, but then the process died before it ended. No result, GPU util = 0%

any clues ?

[Feron]

I was bored so I made this

Code:

#import pyopencl as cl
#import numpy as np
import secp256k1 as ice
from tqdm import tqdm
import random
import base58
import time
length = 3 #12 length is base58 for 66 address
num = 1 #stack world write one number code run 10 time faster running
randStr = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
for x in tqdm(range(100000000)):
 def randomwords(size,chars):
  return ''.join(random.choice(chars) for _ in range(size))
 def cpu_gen(length,num,randStr):
  str_list=[]
  #cpu_start_time = time.time()
  for i in range(num):
   x0 = str_list.append(randomwords(length,randStr))
   x1 = ''.join(str_list)
   ba = base58.b58decode(x1).hex()
   xx = int(ba,16)
   ke = ice.privatekey_loop_h160(0,0,True,xx).hex()
   if "7025b4efb3ff42eb4d6d71fab6b53b4f4967e3dd" in (ke):
    f=open("collision.txt","a")
    f.write(str(xx)+"-"+(ke)+"\n")
    f.close()
    #cpu_end_time = time.time()  # Get the CPU end time
    #timeGap = cpu_end_time - cpu_start_time
    print(str_list,x1,ba,xx)
    #return timeGap
 cpu_time = cpu_gen(length,num,randStr)
 #print("CPU Time: {0} s".format(cpu_time))

[Andzhig]

@Andzhig And if we increase one more character of address 16jY7qLJn & 'x' then most binaries are started from '111'

few examples -

16jY7qLJnxLQQRYPX5BLuCtcBs6tvXz8BE   1110000000100110101001101101010100100011010011001000100000110110000   7013536A91A6441B0
16jY7qLJnX9uchnyf26t3QJnsUf78Xdikb   1110010000101000111010000001111110010000001011001101111011100000   E428E81F902CDEE0
16jY7qLJnX9eX8j612s8fnbn6uzR48xjua   1110100000001101111010110011001110101001011001111010000010001111   E80DEB33A967A08F
16jY7qLJnx2EZZumnYFke3GutCrRnHKs1M   111010110100110101001101101010111010101000110011101011001010110000   3AD3536AEA8CEB2B0
16jY7qLJnx2ixrxCnTLSraerkgyB3YYAiT   1110110111111001110011010110000000110101011011011100110000011001   EDF9CD60356DCC19
16jY7qLJnxHBp3dqwV2kzYq1LucfZzgxsH   1110111010111001101010110011001101001101111100100111011100001101   EEB9AB334DF2770D
16jY7qLJnX2cZXJ78wV1ef42e7cLAZJ1Vn   1111111000101000011001011100011011011011111111101100001110000011   FE2865C6DBFEC383
16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN   1111011100000101000111110010011110110000100100010001001011010100 F7051F27B09112D4

Could this also be some logic?

can you shed more light on this issue

you still don't understand the meaning sense of the hash function? "more light" > what is random? you take a coin and flip it 1 time, it may come up heads or tails. what happens if you flip a coin 10 times in a row, according to the theory of probability, either 10 heads or 10 tails can fall out. if you want to get 5 heads and 5 tails (in any order) you will need to flip a coin in series of 10, 2^10 = 1024 (1024 by 10). to drop all possible combinations from 10 heads in a row to 10 tails in a row, for all tosses in a row 1024 by 10, you need to flip a coin, 1024^1024=... when we start looking at the numbers generated when creating a bitcoin address (any or the address itself or its private key or its 160 hash in any form, hex, dec, bin) we get some parts of this huge number 2^10 = 1024 (1024 by 10) <> 1024^1024=... if you take 3 bits, 2^3=8, 8^8=16777216, then we start looking from 1 to 2^160 what we have in rmd160 hash in hex or dec

someting blablabla
...

1111101110010000010011001101000011011011000101101111100110000011100011011110010 1101011011011101111100000100100110000001010101110011001000000111000100000111101
1111101110010000010011011101010001011110010001010101111001100100101001001001000 1010001010111001000001111010110110000110010101010100001100011111100000110111111
1111101110010000010000101000101001011101000101100110011001100110111110110010000 0011000111101001111110011101100110100010110011110100110011111010000101000000010
1111101110010000010011110100011011001001011101100011111101001110111010000111011 0001001100010000010011000110111010111010110010011001001111010010100000010100001
1111101110010000010011111001001101010000001111001001110001101011110000111011011 0111000010010000111110000100000111010010001000110010111010110111000110000011111
1111101110010000010011000111010011111010010100001000011000001100110010010110001 1010100111011011111111001101001111100000101000101000000110011010110110110111000
1111101110010000010000000110100101101111101110001100000111111001100110111011111 0010000010110100011110101010101010101000100110101100010001111000000000111110001
1111101110010000010000011010010110100011111111100110001101001111001000110101011 0010100010010101100111100010000000110101000001101101111001011101010100101010101

the principle is preserved that vertically and horizontally > 2^3=8, 8^8=16777216


11111011
11111011
11111011
111
111
111
111
111

how many such sections will fit into 2:160 > 1461501637330902918203684832716283019655932542976 / 16777216 = 87112285931760246646623899502532662132736

we will split our 160 bits by 3 bits into sections


111 110 111 001...
111 110 111 001...
111 110 111 001...
111 110 111 001...
111 110 111 001...
111 110 111 001...
111 110 111 001...
111 110 111 001...



11111011 10010000 01001100...
11111011 10010000 01001101...
11111011 10010000 01000010...

11111011 10010000 01001111...
11111011 10010000 01001111...
11111011 10010000 01001100...



of course we can't look further from where they fall from for each row > 16777216^16777216=...

with a horizontal representation, we get 160hesh/8bits = 20 parts.

8 bit 2^8 = 256, 256/20 = 12,8

2^1
1461501637330902918203684832716283019655932542976/12,8 = 114179815416476790484662877555959610910619729920 steps
2^160

256^256=... huge number 3231700607131100730071487668866995196044410266971548403213034542752465513886789 0893197201411522913463688717960921898019494119559150490921095088152386448283120 6308773673009960917501977503896521067960576383840675682767922186426197561618380 9433847617047058164585203630504288757589154106580860755239912393038552191433338 9668342420684974786564569494856176035326322058077805659331026192708460314150258 5928641771167259436037184618573575983511523016459044036976132332872312271256847 1082020972515710172693132346967854258065669793504599726835299863821552516638943 7335543602135433229604645318478604952148193555853611059596230656


16777216/12,8 =  1310720 steps, 2^1 to 2^160, 1461501637330902918203684832716283019655932542976 / 1310720 = 1115037259926531157076785913632418075299020,8

256^256=... huge number / 1115037259926531157076785913632418075299020,8

3231700607131100730071487668866995196044410266971548403213034542752465513886789 0893197201411522913463688717960921898019494119559150490921095088152386448283120 6308773673009960917501977503896521067960576383840675682767922186426197561618380 9433847617047058164585203630504288757589154106580860755239912393038552191433338 9668342420684974786564569494856176035326322058077805659331026192708460314150258 5928641771167259436037184618573575983511523016459044036976132332872312271256847 1082020972515710172693132346967854258065669793504599726835299863821552516638943 7335543602135433229604645318478604952148193555853611059596230656 / 1115037259926531157076785913632418075299020,8 =~

2898289342675449871993098867672270812704240074863894775739976204579701715524344 5980591244385169006487474859731523184059403721470360895667790293862650383583527 8052308371150131655537851476057700318587873331791124614866020470257907019747447 1073288393330068706379548507509145858817458460347497468230852750261100385960260 0438313585964807278885206604007966494048122967982378718514987992376064111499830 2154324000491294951584421374564447449664912755949011836586456519390866498333142 8684237600062725568520340756025511278116285953620110095472786524359663371614992 7614893228693106196480

in general our 2^3=8, 8^8=16777216 fall into their position from the general 256^256=... huge number...

in the first column, theirs fall out all over, in the second one, etc. when presented vertically and similarly when recalculating and converting in horizontal...

instead of constantly flipping a coin, we initiate with Mersenne twister and hash functions (256,160hashs) by initiating the creation of a bitcoin address using a number, we get a fixed result instead of randomly generating a constantly new one (but it randomly takes it from a large number), but this number itself 2^160 or 2^256 is still fixed and falls out of the total huge number that goes into infinity 2^3=8, 8^8=16777216, 16777216^16777216... etc

in general, everyone is picking something and looking for their own ways))

https://youtu.be/AYWoDqQmm1o?t=128

[citb0in]

I was bored so I made this

Code:

#import pyopencl as cl
#import numpy as np
import secp256k1 as ice
from tqdm import tqdm
import random
import base58
import time
length = 3 #12 length is base58 for 66 address
num = 1 #stack world write one number code run 10 time faster running
randStr = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
for x in tqdm(range(100000000)):
 def randomwords(size,chars):
  return ''.join(random.choice(chars) for _ in range(size))
 def cpu_gen(length,num,randStr):
  str_list=[]
  #cpu_start_time = time.time()
  for i in range(num):
   x0 = str_list.append(randomwords(length,randStr))
   x1 = ''.join(str_list)
   ba = base58.b58decode(x1).hex()
   xx = int(ba,16)
   ke = ice.privatekey_loop_h160(0,0,True,xx).hex()
   if "7025b4efb3ff42eb4d6d71fab6b53b4f4967e3dd" in (ke):
    f=open("collision.txt","a")
    f.write(str(xx)+"-"+(ke)+"\n")
    f.close()
    #cpu_end_time = time.time()  # Get the CPU end time
    #timeGap = cpu_end_time - cpu_start_time
    print(str_list,x1,ba,xx)
    #return timeGap
 cpu_time = cpu_gen(length,num,randStr)
 #print("CPU Time: {0} s".format(cpu_time))

what do you want to tell us? you are doing collission on the hash160 of puzzle 16, what for? please explain and add some info, the code just sitting there alone without information is useless.

[Feron]

I consider base58 to be one of the weakest methods for scanning, it slows down the speed and so on. As for the code, I was interested in this setting, it adds one letter to the base58 private key, such a pyramid, I used to deal with it with binary, but I forgot about it

Code:

#import pyopencl as cl
#import numpy as np
import secp256k1 as ice
from tqdm import tqdm
import random
import base58
import time
length = 1 #12 length is base58 for 66 address
num = 32 #stack world write one number code run 10 time faster running
randStr = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
for x in tqdm(range(1000000)):
 def randomwords(size,chars):
  return ''.join(random.choice(chars) for _ in range(size))
 def cpu_gen(length,num,randStr):
  str_list=[]
  #cpu_start_time = time.time()
  for i in range(num):
   x0 = str_list.append(randomwords(length,randStr))
   x1 = ''.join(str_list)
   ba = base58.b58decode(x1).hex()
   xx = int(ba,16)
   ke = ice.privatekey_loop_h160(0,0,True,xx).hex()
   if "7025b4efb3ff42eb4d6d71fab6b53b4f4967e3dd" in (ke):
    f=open("collision.txt","a")
    f.write(str(xx)+"-"+(ke)+"\n")
    f.close()
    #cpu_end_time = time.time()  # Get the CPU end time
    #timeGap = cpu_end_time - cpu_start_time
    #print(str_list,x1,ba,xx)
   print(x1,ba,xx)
    #return timeGap
 cpu_time = cpu_gen(length,num,randStr)
 #print("CPU Time: {0} s".format(cpu_time))

here is the full speed version of the old code, don't forget this code will never crack 120 ddd why because it works like this it gives it some full number and the last 6 nulls it scans sequentially what gives you at 4m keys per second 3 full keys per second simply put it only scans the last numbers of the private keys

Code:

from timeit import default_timer as timer
import secp256k1 as ice
import random
while True:
 stackk = 1000000
 target = b'\x04n\xa89\xd2(G\xee\x1d\xce;\xfc[\x11\xf6\xcfx[\x06\x82\xdbX\xc3[c\xd14.\xb2!\xc3I\x0c\xd41>@\n\xc0%\xa1\x8fr\xb7\xe4Hz:Ggl\x1e\x97\xbao\x81\x19\xe9smK\x8cL\xe2\xa9'
 number = round(random.getrandbits(24)/stackk)
 public = ice.scalar_multiplication(number*stackk)
 startt = timer()
 checkk = ice.point_sequential_increment(stackk,public)
 #startt = timer()
 if target in checkk:
  f=open("results.txt","a")
  f.write((target).hex()+" -start number for key "+str(number)+"\n")
  f.close()
 print('Key/s:'+str(stackk/(timer()-startt))[:7]+' Time:'+str(timer()-startt)[:3]+' start number for key:'+str(number))

.hex() this slowed down the code because it had to convert the entire chain of 1,000,000 bytes public keys to hex

[Evillo]

bitcoins security is literally based on how many numbers it is

This should be made as a banner in all Bitcoin related websites for newbies to see over and over until sunk deep in their subsconscious.

[digaran]

snip

Please use scientific notation for large numbers, it's really hard navigating the page reading your post.
Btw, what's your point? I see no conclusion.

I have something for you, want to see if you can figure something out of it.
The following is a real private key:

Code:

5KeysCompromisedStopUsingBitcoinSELLRightNow8AzDLiL

Could you figure out what are the other possibilities regarding private keys with the huge number of keys that exist?

A fun fact about bitcoin is that private key is private but is not a secret, because they are all known, out there sitting for anyone to see them, however this is not the case about addresses, they are actually the secret element which nobody seems to realize, this fact is hiding in plain sight.
Now after reading some of your posts, can you find any relation between addresses and their private keys, such as in binary/hex/decimal/wif?
Let me give you a hint, there is a relation but it's spread throughout the entire key range, we can actually map out all the addresses just like there is a map of all private keys, but trying to map the addresses will take decades with 50 super computers, though if we had a QC and 10,000,000 TB of storage, we could create that map in less than 6 month.

[citb0in]

what is your question about this uncompressed WIF key? What you like to find out ?

Here's some info on the key you posted:

legacy address : 1E51wVrX15ednjQaZxRhiT1xj3676ELCsR (compressed)
legacy address : 1MQ1xZC4dkT74GUCY1KBEoPGRCkBXRAAzo (uncompressed)
bech32 address: bc1q3awp2k93nautglcs442q74qmsm6kypz57ztfgs
segwit address: 3EJEq6wS5ATuFk6gtPzNb7rj1oS79pBcTU
hash160           : 8f5c1558b19f78b47f10ad540f541b86f5620454
private hex key: f2435855f04260e145878411e97020bb2b4f327bf45b8458ed8550aabac3918c
WIF                  : L5Ldzb7SrEqSPpZ5sHfea2sSbxKtq3DRYMrLk6zFTmG9tHkVhN4Y
uncompressed : 5KeysCompromisedStopUsingBitcoinSELLRightNow8AzDLiL
pubkey             : 6a78792c68dca59a8cb07edae96d4e97130307a3380a6357d07c2486d20b1dbd

[digaran]

what is your question about this uncompressed WIF key? What you like to find out ?

I wanna know what are the all possibilities regarding private keys, for example, what else could we find on private keys, what sentences could go into a valid pk?
Since this challenge has somewhat a more educational approach towards blockchain infrastructure, I'm asking this here.

In the process of generating bitcoin addresses, what are the needed factors, a decimal string, public key string, hashing, adding checksum, calculating the private key and generating the address. What can we set/change manually? And how to know if our input will result in a valid address?

[nc50lc]

-snip- , what sentences could go into a valid pk?

As long as the sentence consist of base58 characters (base58), you can make your own valid WIF private key just like your example, but there's a limit on the first few characters:
If Uncompressed, the start of your sentence (after '5') is limited to K or J.
If Compressed, the start of your sentence (after 'K' or 'L') is limited to 1~5 for 'L' and w~z for 'K'.

For example, these are valid uncompressed WIF private keys:

• 5Kiwis5Jackfruits3Bananas7Papayas2GirLs1Cupxxw6wjAK
• 5Jackfruits5Kiwis3Bananas7Papayas2GirLs1Cupxxv2BjX2

Valid compressed WIF private keys:

• KwakKwakKwakKwakKwakKwakKwakKwakSaidTheDuckxxsHfq1vE
• L2Bitcoin7DragonBa11s6Pokeba11s4EXPtoMaxLeve1XtvCz6P
  
  

It'll be easy to do that after knowing how WIF private keys are encoded: https://learnmeabitcoin.com/technical/wif
It's basically a reverse of that process.

Example process (compressed sample 1):

• 1. Type your preferred sentence, the starting characters should be valid and it shouldn't reach the checksum (about 46 chars inc. L/K)
  -> KwakKwakKwakKwakKwakKwakKwakKwakSaidTheDuck (43 characters, starts with 'Kw')
• 2. Add temporary characters to fill the valid compressed WIF length of 52 characters.
  -> KwakKwakKwakKwakKwakKwakKwakKwakSaidTheDuckxxxxxxxxx (52 characters)
• 3. Decode it with any Base58 tool and get the Hexadecimal value (the first byte should be 0x80; otherwise, there's something wrong with the input):
  -> 800ad27bc997b00cb75c5dd33106c68f02f5e77bbb1dd537e932446da5992d68b333c705ac11
• 4. Drop the "invalid checksum" bytes, which is the last 4Bytes and "fix" the compressed flag into '0x01'
  -> 800ad27bc997b00cb75c5dd33106c68f02f5e77bbb1dd537e932446da5992d68b333c705ac11
  -> 800ad27bc997b00cb75c5dd33106c68f02f5e77bbb1dd537e932446da5992d68b301
• 5. Compute the correct checksum from the first four bytes of SHA256D of the above.
  -> SHA256: f2371367022b6894364e13e0f2446f77422a6208511c964f31aeeda5246f27c8
  -> SHA256: 745a98efd82176195036e59f313e2f27a0725e85e0ea18a518a27870cf87be29
  -> First 4Bytes: 745a98ef
• 6. Append the checksum to the result of step 4
  -> 800ad27bc997b00cb75c5dd33106c68f02f5e77bbb1dd537e932446da5992d68b301745a98ef
• 7. Encode the above in Base58
  -> SHA256: KwakKwakKwakKwakKwakKwakKwakKwakSaidTheDuckxxsHfq1vE
  
  

For uncompressed:
Do all the steps aside from the "compressed flag" part (step4), the number of characters is only 51 (step2) and the starting characters should be for uncompressed WIF.

[Critical_Thoughts]

I am the creator.

Hi mysterious entity, I am here to express my thoughts , and I will base my assumptions on you being the coy and famous Satoshi, the one and only BTCitcoin inventor.
First things first, Thank you for the work and efforts on making this new open source technology regardless of it's flaws and limitations! it's benefits and utilities outweighs the minor flaws. The outcome of your invention is paramount and the mark you have left will remain recognized and relevant for thousands of years in the future, you will be remembered as the founding father of the decentralized digital technology.

You are quite right, 161-256 are silly.  I honestly just did not think of this.  What is especially embarrassing, is this did not occur to me once, in two years.  By way of excuse, I was not really thinking much about the puzzle at all.

This kind of behavior shows a little bit of your character, it seems that you are reckless (maybe very busy having too much on your mind?), apparent if one goes back in history reading your posts, seeing your first few years of Bitcoin development leaving the scene for others to take control> irresponsibility in regards to the community you were so fond of that made you come up with the Bitcoin solution.(perhaps there was no need to continue publicly working on Bitcoin since you left it in good hands?) (which so far has proven to work as you intended, at least that's what I think). The irresponsible part is about the fact that you never showed up from time to time to share your thoughts with us, that just hurts our feelings because we all love you and respect you as an esteemed founder of Bitcoin.

I will make up for two years of stupidity.  I will spend from 161-256 to the unsolved parts, as you suggest.  In addition, I intend to add further funds.  My aim is to boost the density by a factor of 10, from 0.001*length(key) to 0.01*length(key).  Probably in the next few weeks.  At any rate, when I next have an extended period of quiet and calm, to construct the new transaction carefully.

A few words about the puzzle.  There is no pattern.  It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty).  It is simply a crude measuring instrument, of the cracking strength of the community.

Please, you are anything but stupid, I do realize at current price or the price back when you created the puzzle the amounts were not much, but giving it a few more years, people would sell their houses to buy hardware in order to solve any of the remaining puzzles.

Finally, I wish to express appreciation of the efforts of all developers of new cracking tools and technology.

Currently I'm working on a few ideas trying to formulate a new algorithm focused on breaking the [1]ECDSA and [2]RIPEMD-160 into smaller pieces, reconstructing the [3]SHA-256 to make a new hash function that displays the entire hashing operations on the screen or saves it on a file. These are the small steps I'm working on when I have spare time. my issue is funding, third party sponsors would require information and collected results/data, my work can NOT be made public if I achieve what I'm looking for. unfortunately further explanation is not wise.
I have an old laptop and need a strong computer with decent GPUs, that would cost at least 20,000 USD, Ca not afford it. If you are intrigued to see some new attack vectors on Bitcoin(2 years at least is needed) I will send you a PM to convey my request.

##This puzzle at this time with these baby tools available is wasting time, first quantify the numbers you need to search through to find the remaining ones, then open the calculator to enter the values, decimal/speed/ s, /60 for one minute/60 for one hour, etc.

[1]= [2]= [3]= old, outdated.

[citb0in]

Currently I'm working on a few ideas trying to formulate a new algorithm focused on breaking the [1]ECDSA and [2]RIPEMD-160 into smaller pieces, reconstructing the [3]SHA-256 to make a new hash function that displays the entire hashing operations on the screen or saves it on a file. These are the small steps I'm working on when I have spare time. my issue is funding, third party sponsors would require information and collected results/data, my work can NOT be made public if I achieve what I'm looking for. unfortunately further explanation is not wise.

I have an old laptop and need a strong computer with decent GPUs, that would cost at least 20,000 USD, Ca not afford it. If you are intrigued to see some new attack vectors on Bitcoin(2 years at least is needed) I will send you a PM to convey my request.

##This puzzle at this time with these baby tools available is wasting time, [...]

You contradict yourself enormously in one thing. You ridicule the current state of the tools and technology and the long computation time it requires to solve such puzzles, but at the same time you complain that you have a weak old laptop and need hardware with a powerful GPU that will cost you over $20,000 and you can't afford it. Do you seriously think anyone is going to fund you that amount based on the presentation you're giving here?

If you have such a good handle on the three algorithms you mentioned and have found SUCCESSFUL ways to take shortcuts, you certainly won't need a sponsor because you are a wealthy (I deliberately didn't say rich) man with your knowledge.

I have to agree with you on this part though: you will most likely not find anyone who will support you financially without wanting to know when and what kind of return they will get. This is not about a handout. Besides, I read here only words and promises without factual and professional background. Some might suspect a scam but I leave that to others. 

[Critical_Thoughts]

Some might suspect a scam but I leave that to others. 

You are correct, I was under the impression that whoever designed this challenge was after finding weaknesses and would sponsor any study done to accelerate the process, hence the mention of _"funding". I just couldn't help it to neglect mentioning the BIG elephant in the room, when I said using current technologies are a waste of time. Thank you for pointing out some facts which I missed myself. I'm sure someone will be able to sneak a peek over the event horizon of elliptic curve sooner rather than later.

[citb0in]

Please use full quotes to keep the context

You contradict yourself enormously in one thing. You ridicule the current state of the tools and technology and the long computation time it requires to solve such puzzles, but at the same time you complain that you have a weak old laptop and need hardware with a powerful GPU that will cost you over $20,000 and you can't afford it. Do you seriously think anyone is going to fund you that amount based on the presentation you're giving here?

If you have such a good handle on the three algorithms you mentioned and have found SUCCESSFUL ways to take shortcuts, you certainly won't need a sponsor because you are a wealthy (I deliberately didn't say rich) man with your knowledge.

I have to agree with you on this part though: you will most likely not find anyone who will support you financially without wanting to know when and what kind of return they will get. This is not about a handout. Besides, I read here only words and promises without factual and professional background. Some might suspect a scam but I leave that to others.  

So the part you quoted was referring to you

Some might suspect a scam but I leave that to others.

The creator of the puzzle has funded, every single puzzle has its prize money ready in the pot and whoever solves it can collect the prize. Your statement once again does not correspond to the facts.

[Yoshimaka]

?

Mister T. Hello, are you still here? I found your main account to be inactive for years and this one was active in 2019. How can we talk? I really need your help. By the way, what are you doing with puzzles? You are a genius yourself, no need to involve the community to solve the ECC problem.

Sent you an email from yoshimaka@grr.la to the email satoshin@gmx.com please read.

[Kostelooscoin]

for x in tqdm(range(368934881474191232,73786976294838206466)):

OverflowError: Python int too large to convert to C ssize_t