A friendly message to @Satoshi aka puzzle designer ;

You owe puzzle solvers nothing, once they find a key and withdraw bitcoins out of it, the mission is accomplished, you can then reveal the private key for public, of course you could give them a month or so in order for them to withdraw those garbage coins out, if they decide not to, it's  because they don't want them.

We have worked as much as the solvers, even more so and we deserve to have a look at the keys we were trying to find for months, otherwise working on these puzzles is a waste of time for those not having lots of rigs to kangaroo the keys.

Since you know the keys and you don't owe the solvers, it'd be great if we could have #120 and then #125 private keys. Please.

It's not a hash per second, but key per second, generating public key from a private key, hashing the public key 2ice to generate the address, an old laptop with low end GPU  can search for 25 million + keys per second, good GPUs can do billions of keys/s.

From 5 to 160, every 5 puzzle there is an exposed public key, so since we already have the public key we can skip 2 hashes and only generate public keys, and that also is not 1 key at a time, we could practically subtract or add 10,000 trillion keys per second, just a minimum, that's why they can be solved faster.

Have a look at bitcrack and other tools to see what speed you get and compare with your tool.

Is there any way to figure out the first character for #160 private key?, I figured since working more than 3 months on #125 resulted in a failure, it's better to work on something which nobody would go near for years. Lol

Why would you wanna waste time and energy on address only puzzles when you can spend the same time and use the same resources to search for puzzles with known public keys,  either learn how to utilize bsgs for public keys or use kangaroo.

I guess I was speaking arabic right? 😅 that is math right there, follow up on it to get some where.

About compiling, I'm the worst person to ask, because I have the same problem as you, when I for example open visual studio  it's like an alien world to me. In case you didn't know, I used WP's ready to use for windows tools.

Is that really the real question though? It has easy answers, with public key you can solve thousands of times faster, without public key, you either go directly to brute force all the keys in the range, or you'd go breaking 2 hash functions just to reach the public key, so it is more wise to skip all the drama and stick with the easy way.

I'd say up to puzzle 79 is solvable in a few years given the price going up to make it worth the effort, however even puzzle #159 can be cracked  with special ASICs as long as the prize is more than the cost, I suspect that we will never see more than #79 solved in our life time and this puzzle will remain a legacy among other achievements of Satoshi for the future generations!

Took me 4 mins to correct the quotes you misplaced lol.

---

I'm the last person you'd want to teach you something, I just share what I know, they might be incorrect sometimes.

What you need to know about public keys, ignore their size and char length, it's all smoke and mirrors, they are simply representations of private keys, and private keys are simply ordinary numbers but very big ones.

Hexadecimal keys can make our work easier, for instance, if you have a large number like 3637343230303931363537383831353435
By the time you can figure out how to extract a certain number out of that, you'd be spending a few minutes, but if you convert to hex  you will get this
b355b9d94ef43E58a7f80fe3b85b

And in seconds I can select my target and then by guess work I'd take b as my first char assuming we know the first char is b, so I'd go with b000000000000E00000000000000  then I subtract from target to get
355b9d94ef43058a7f80fe3b85b
Then I go with this
bffffffffffffeffffffffffffff  subtracting target from it to reach
caa4626b10bc0a75807f01c47a4  and then I add the last result to this  +  355b9d94ef43058a7f80fe3b85b to reach =
ffffffffffff0ffffffffffffff
And just like that I now know the E I guessed is really there otherwise I'd see something else instead of 0 in the middle of fs  =  ffffffffffff0ffffffffffffff . 😉

Fun fact, 99% of times when I share something I know with others, I learn something new then and later on, this is why we need to share our knowledge, we gain more than we already have by sharing.

Take it easy tiger! 11 M keys takes less than a second for my laptop to find and there is hashcat, it can search all alphabet, numbers, symbols, all languages, dead or alive and when they take your coins, don't come here whining about it, lol.

Last year I talked about vanity private and public keys, it's more of a decorating nature, not that vanity public key is even possible.  But vanity private key is a bad idea, memorizing your wife or gf's birthday is the ultimate memory challenge for most men, let alone memorizing a WIF key.

It is not recommended, and it has no use really, because you can never show it off to people, the last 6 chars are nothing to worry about, it would take less than a second, the first 2 characters are limited, so you are too much vulnerable as it is.

How exactly do you search in random ranges to find a specific range for your target?
Since the puzzle #125 is solved, we will see more interest on this subject for a while, you can be sure all the puzzle keys are in the said ranges, just like all the solved and revealed ones.

In order to reduce the bit range, you'd need to correctly guess the private key characters, so if the key is 1a5f5da67870cc  if you correctly guess the first 3 chars, you can drop 1a5 from your target, all the tools that exist are doing the same thing somehow, they just do it differently, one is trying to divide, another one tries to subtract, and they are all primitive tools without any effort put in to develop them.😉

Isn't kangaroo doing division to decrease the search time? As long as you are dividing +n key, you can even reach G itself.

---

Since you don't know anything about the private key, the easiest way is to guess the last digit and if it's even, at least you can divide by 2 for sure.
And if you are dealing with prime numbers, look at N of secp256k1, if you just subtract 1 from it you can divide it by dozens of already known divisor numbers.
Anyways for now the puzzle #125 has been solved, it's  time to focus on the next one #130, we'd either find it or die trying, right? 🤣

We need to see the private keys for #120 & #125, we deserve that much.

Nice one and congratulation, I was working to post some more hints, but it appears it has been already solved. It would be nice to know the private key if that's OK.😉

Nice, any windows binary? I don't use python.
This is good for display, not real world use to store.
Also can we count how many of a certain checksum exist in a subgroup?

First delete your other 3 identical threads on the same subject, then do some more reading on the same topic you learned about that puzzle. This is one of the features of block chain technology, smart contracts etc.

In short, the solver sends his address with the answer of the puzzle, that's the destination, if your coins sit on your private key, do they need a destination? You will be the one giving them one, so the answer of the puzzle is like the private key for those puzzle addresses.

Multiply your public key by this key
7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0
Key above is N/2, or 0.5 and if you for example multiply 4 by 0.5 you'd get 2, this is a simple operation.
There is also a java calculator on github, https://github.com/MrMaxweII/Secp256k1-Calculator
You can put public key and select division then put 2 and divide or any other number you like.

About dividing you should know, every single even public key has an odd pair we call it inverse key, aka 02 and 03.

If the pub key starts with 02 and it's private key ends with 1, 3, 5, 7, 9 the inverse key must end with 2, 4, 6, 8, 0.

Now let us practice :

Our target pub key :
03f42cde25a364c9764a4c60f762337c0a1a9d27805c89b59bc845e18a93db4ac9

It's private key :
00000000000000000000000000000000000000002880422a1ab3e513482869b2
 Decimal ( 12534455350639729112533985714 ) ends with 4 so it is even.

Inverse pub key :
02f42cde25a364c9764a4c60f762337c0a1a9d27805c89b59bc845e18a93db4ac9

It's private key :
fffffffffffffffffffffffffffffffebaaedce686c85e11a51e7979880dd78f
Decimal (  115792089237316195423570985008687907852837564279062369927254523412405627508623  ) ends with 3 so it is odd.

Now it doesn't matter which one of the pub keys you are dividing, it will divide the even one because there is no fraction in ECC.

If we divide our target pub by 2 we will see :
0312d8734901f0f88e3b396c4fa66454543cd8837bbb31ea177cc19b99a8a79ed1
Private key :
0000000000000000000000000000000000000000144021150d59f289a41434d9
Decimal (  6267227675319864556266992857  )
Inverse pub :
0212d8734901f0f88e3b396c4fa66454543cd8837bbb31ea177cc19b99a8a79ed1
Private key :
fffffffffffffffffffffffffffffffebaaedce69b087f26b2786c032c220c68
Decimal (  115792089237316195423570985008687907852837564279068637154929843276961894501480  )

Then if you try to divide this
0312d8734901f0f88e3b396c4fa66454543cd8837bbb31ea177cc19b99a8a79ed1
Or the -n aka 02 version of it, doesn't matter which one since both will give you the same result which is :
0222db101c46b9d0f52e30f1be2565c67a9e75d3104fda0b75fcbec3fae320b88d
Private key :
7fffffffffffffffffffffffffffffff5d576e734d843f93593c360196110634
Decimal (  57896044618658097711785492504343953926418782139534318577464921638480947250740  )
Inverse key :
0322db101c46b9d0f52e30f1be2565c67a9e75d3104fda0b75fcbec3fae320b88d
Private key :
7fffffffffffffffffffffffffffffff5d576e7361c460a86696288b3a253b0d
Decimal (  57896044618658097711785492504343953926418782139540585805140241503037214243597  )

So, tell me, are we close to our target or did we just distanced ourselves from target by 2^255 difference? If you had more questions, happy to answer if I know the answer.😉

Some updates on my previous hints!

If we add this key (later multiply it by 2 and 4 to see what result you get)
0209393576e52df0c10a165b31ac6d1da4ffb01da64c10fc496765ac823bdd7b3b
To this known key
0x4000000000000000000000000000000
We will reach this one
028e99d794f780a074945a2c53abb69184f46f07a707aab1a618a849f935224d0a

And if we double each of them, we will see something interesting, and I didn't even divide any key using division op.

A few hours ago you were wondering how to use brute force applications, now you are a cryptography expert?

Yw.
By special thing you mean my suggestion to improve this tool? Well to be able to do that we need the code written and developed, and alberto is MIA for some time now!

Good luck with your test, I haven't left the testing grounds yet, so welcome on board, and keep grinding.

You don't need to check for balance, you are already searching for addresses with balance. Not that it matters, because you'd need to grind 10 trillion keys a second for a few thousand years to find one of the smallest puzzle keys.

By X point you mean -z argument? That just excludes 02 and 03 from output keys, it is useful if you don't want to include both 02 and 03 x coordinates, that way you just add one with no 02, 03, it saves space and increases speed.

Show me you command line, lets see what you are doing.😉

---

You know I have been thinking about a feature addition, we could generate for example 10 M known private keys and only keeping the last 8 characters of their public keys while the private keys are completely saved, then we could run addition and subtraction operations while the program automatically checks all the result against those 10M known keys.

One time I had the public key for 0xb, which is key number 11 in decimal, now imagine how many easy and known keys are in our output files but we never notice them, but having the ability to check all on the fly would be a great addition and improvement IMHO.