I personally have no trust in intermediary sites like Slipstream Mara. These are all delusional thoughts that are expressed. Anyone who can solve Puzzle 71 can create a transaction with a gift of 1 million Satoshi and broadcast it on the network. Rest assured, with this reward, miners will not hesitate for a moment to accept it. Your transaction will be confirmed and there is no need to worry until the robots try to reach the public key from the private key.

Random brutus of 22 digit mini keys (GPU version)

The database contains 4524 addresses, each of which belongs to Series 1.
https://bitcoinpuzzle.ru/btc.txt

If a mini-key is found, the information about it will be saved to a file. FOUND.txt .

In ARGS.txt arguments can be passed

https://bitcoinpuzzle.ru/upload/000/u1/f/6/f6602451.png

The -t and -b arguments:

These values depend on your graphics card.
Start with -t 128 and -b 500, then experiment. On the RTX 3060, for example, -t 256 -b 1000 gives the best result.
Monitor the loading of video memory (GPU-Z or nvidia-smi).
The argument is bits:

The value of 12 is reasonable: the table will have a size of 2^12 = 4096 cells.
You can increase it to 14-16 if there is enough memory and you see a lack of caching.
If the value increases, you will have to wait a bit.
The argument is alfabet:

It is used to generate random keys.
Do not change it until the test key is found!
Test key found! All working correctly...
When configuring arguments, check… Whether or not the test key is found in the database.

"What, is the antivirus swearing?"

There is protection in this software

Download here
https://bitcoinpuzzle.ru/casasciusbtc.rar
https://www.virustotal.com/gui/file-analysis/NWE5MDg2ZDY5Y2MyNTc4MmRkZGJjMjViMzc0OTcyZDE6MTc0ODM1NzYzMA==

yo\(~

57-bit DONE after 8 days!

The found S actually had 58 leading bits of 0 (57 were enough).


https://talkimg.com/images/2025/08/04/UH9t4a.png

Server logs...


And total running stats....


So that was around 59212 trillion signatures.

Total costs: 110 $

This was emotional. Up to the lucky hit, the best results that I got were all 54 bits or less, and I was starting to wonder whether the risk is worth it. Then 58 hit hard to compensate for the unexpected bad results

May I ask how the solvers of puzzle # 67 and # 68 bypass the public memory pool to prevent transactions from being revoked by others?

Did they use their own machines to mine? Do they have that much computing power?

Which experts can explain the principles and processes in detail? thank you!

Hello guys!
My implementation of Pollard-rho algo:
https://github.com/Dookoo2/Mark1
38 minutes for solving 80 bits puzzle with half billion of DP, 14 minutes for solving 70 bits with 200 millions of dp (after phase 1 for collecting and storing DP).
AVX2 bloom filter, compact DP table, Brent loop detection and others features.
May be useful for somebody.
Have a nice day:)

Apparently, this is a fork of what you requested, as they acknowledge it in their GitHub.
https://github.com/Qalander/Minikeys

Apparently, this is a fork of what you requested, as they acknowledge it in their GitHub.
https://github.com/Qalander/Minikeys

I must admit that until recently I was not aware of existence of mini-private-key format... I have found information about it accidentally and I decided to play a little with it.
So, just to recall some information:
The size of 'physical' items forced creators to find a way how to encode information about Bitcoin private key on a small area. Typical WIF, which has more than 50 characters would be too long. So, the new format has been created. Initially minikeys had 22 characters, later 30 characters. What is similar to WIF is that minikeys are build based on Base58 characters - that format excludes characters which looks similar to other, what could be problematic for user. That way, for example, characters like 'l' (lowercase L) or 0 (zero) and O (uppercase o) are excluded. Later, creators decided to exclude "1", so in fact the new format "base57" is used. And just a detail - minikeys starts with a letter "S".
The main difference between WIF and minikeys is that WIF encodes the exact private key, while minikey is in fact more like "brainwallet" phrase - the ways to restore private key is completely different. In case of WIF all we need is "base58 decoding" to retrieve information about private key (and additionally information if we had correct WIF, so decoded private key is really the one we look for). In case if minikey we must calculate hash of a key, just like we do with brainwallets.
What is also interesting, is that minikeys also has some kind of verification if input (the text found on physical item) is correct. Verification is based on fact, that not each combination of characters could be treated as a valid minikey - only when "extended" minikey produces hash which starts with "00" in hex.
All hashes on minikeys are sha256.
Let's take an example (we will work on short keys, 22 characters):
ScatCATcatCATcatCATcat
We must verify if key is correct, to get this information we calculate hash of key "extended" by appending character "?" (question mark).
Because hash starts with "2d", "ScatCATcatCATcatCATcat" cannot be used as a valid minikey;

SkK5VPtmTm3mQKYaJQFRZP
Now we see that SkK5VPtmTm3mQKYaJQFRZP is a "correct" minikey. Then we may calculate hash to retrieve the real private key:

That key gives uncompressed public key
04bf2d4231ca9ec2a49664f5b821bd44ad6cb38c6393936f1e3a6a8f4e0ee81686666e952387a4d d63a2ac7fb8c63737a9c4be142a186c1496d7013569c028143c
which produces hash160 fc258e14e4d1705f4c5a1f77e9a693531de82553
which could be converted into address 1PzEGi7a6UEGCAXtGjZj8kBX2VEHcLMrqd.

Now, let's ask how safe it is. I will focus on famous Cascascius coins - the list of coins (produced and already 'opened') is available online: https://casascius.uberbills.com/ and https://casasciustracker.com/
From serie 1, which was based on short keys (22 characters) and full base58, there are slightly less than 5000 coins still unopened.
I was aware of only one tool to brute-force minikeys and try to attack them knowing public addresses of coins - it was Keyhunt by @albert0bsd (https://bitcointalk.org/index.php?topic=5322040.0)
Just for fun and programming exercise I decided to prepare a small tool for "attacking" Cascascius, but using GPU. Working, but probably not extremely optimized program is available here: https://github.com/PawelGorny/MinikeyCuda
Program may work in two modes - random or sequential.
Sequential processing is very similar to typical WIF solving, where we change character by character and test the result. Initially we test if minikey is eglible for processing (if hash of key+? produces 00), then we hash again to generate the private key. Then we verify if private key produces address we look for. Statistically every 1/256 minikey is "correct" and produced private should be tested.
On my dev card rtx3060 I have performance of about 8mln keys/s, which gives around 30k/s 'valid' keys,
Random mode works quite differently - using GPU we produce bunch of 'valid' keys and then we check all of them. That way we may check much more keys, but we are not able to verify if we do not have duplicates. The corresponding performance is about 600-750k/s.
But what is the possibility of successful attack? Let's calculate:
For short keys, we have 58^21 possibilities = 1,076435e+37. As statistically 1/256 keys are valid, we must test 4,204824e+34 keys.
If we are able to test 500k/s and we are sure we will not have duplicated work, we need:
1 401 608 248 902 228 061 589 725 886 minutes, which gives 2 666 682 360 925 091 441 380 years (if I am not mistaken) to test all the keys.
Calculations for longer keys (30 characters) are left to the reader.
In other words - if you are in the possession of one of coins, I think you may sleep safe.

But if (I have no idea if situation like that may occur) you have lost part of your key, 6-7 characters, maybe more - it would be possible to recover it.

We got robbed of Puzzle 69.

Hello, we are coming out to claim we are the group that solved puzzle 69.
We are a group consisting of 12 software developers in Asia with interest in cryptography. We have been scanning puzzle 66, 67, 68 and 69 since last year.

We have rented several GPUs online to use for the puzzles. Unfortunately, puzzle 66 was solved by

1Jvv4yWkE9MhbuwGUoqFYzDjRVQHaLWuJd (not us)

but got stolen using RBF. Puzzles 67 and 68 were solved by 1 person and then finally we were able to solve puzzle 69.


We are using our custom software written using CUDA C++. Each member has several GPUs which will be given a range to scan. It was really a eureka moment when we were notified that a match was found by one of our members.

We are aware of RBF attack so we used a wallet software (we prefer not to say which one) which does not enable RBF by default, to transfer the coins. But when we checked the transaction, before it was confirmed, another transaction was created.

This is really heartbreaking for me and my group because we spent months scanning the range only for it to be stolen by others. We are contributing part of our savings to pay our GPU bills monthly. We might resort to contacting the wallet software provider but we know that our 6.9 BTC is long gone forever.

Now, our problem is how to pay our remaining GPU bill which amounts to $158,954.07. This is so frustrating! Why can't people play fair and square???

We are accepting donations to help us pay our remaining GPU bill in these addresses:

1BMWUDeiq15EDZETNG49YfdQvLoEzGBjxm
bc1q2pqem06ad053rnt656dta4nej6uqe9p786kjls

Are you talking about that key?


That’s probably a scam. I’ve bunch of WIFs with partial matches in sequence, be careful not to waste your time there.

https://www.talkimg.com/images/2025/04/21/xxPta.gif

For those who think searching for WIF has some magical twist—let me tell you, it's much slower compared to generating an address directly from a private key (hex, bytes or dec).

@nomachine, maybe let the curious minds DM you directly -: this thread’s starting to feel like a rerun marathon. Let’s save the scrolls for fresh stuff!

---

WHICH IS ALMOST 50-50!



Well done! But let’s be real—if we’re talking probabilities, I Still remember, how you got yourself stuck in this argument when you trying to defend someone. Your heroic moment, huh? Maybe now’s a good time to snap out of that mess and chase some actual probability breakthroughs.


Bro demonstration is over now! lets reduce the talk in this forum that we can easily read important posts And thanks for searching all 10 digit seeds for me 

Project 11 has launched a competition where people can win 1 BTC if they break Bitcoin’s Elliptic Curve cryptography and an ECC key using a quantum computer with Shor’s algorithm. The aim is to break the biggest ECC key possible.

According to them, 6 million BTC in over 10 million addresses are possibly vulnerable to quantum computers because of their exposed public keys. That's a value of over $500 billion. The aim of the initiative is to test how serious of a threat quantum computers present.

Project 11 believes that quantum computers will break Bitcoin's 256-bit keys sooner or later. Participants don't have to go that far. The company believes that breaking a 5-bit key is already a significant breakthrough.


Competition Rules:

- Individuals and teams can sign up. No institutional affiliation is needed.
- Participants need to find out how to run Shor's algorithm on current quantum hardware and demonstrate scaling capabilities to 256-bit keys.
- Project 11 has prepared sets of ECC keys from 1 to 25 bits of security. Participants will need to target these key lengths and demonstrate that their methods can crack the provided x-bit key.
- Submit your entries. Participants can include the code, instructions used with the quantum program, a description of their approach, techniques used, and the specs of the used quantum computer.  

The deadline to make the submissions is 5 April 2026. All submissions will be shared publicly.
Those interested in participating can sign up here: https://www.qdayprize.org/register

What do you think, what key length will these white hats be able to crack?

---

Sources and further reading:
https://www.qdayprize.org/
https://x.com/qdayclock/status/1912534686569755044

I will make it short.
Without Bitcoin I would be nothing. Perhaps I would just have an okayish life but not the time freedom I can afford now. Bitcoin allowed me to be global, generous and polite. Thank you Satoshi, Hal Finney and everyone else including you who is reading it.

hi, im currently working on enhancing on Nonce Recurrence Attack. Read: https://eprint.iacr.org/2023/305.pdf

While i was able to recreate the attack describe in the paper, im thinking of enhancing this method. however, the enhance method would require me to generate some fake signatures that still points to the same public key. i vaguely remember that there was a discussion in some topic and someone mention that we could create fake signatures that could still be verified against the targeted public key but it wont be valid. or something to that effect.

Do you get what i am saying? does it make sense to you?  i might not be explaining this correctly. but if you do, what is the formula to do that? i have forgotten the formula.

It’s just a few lines of code, bro—why overcomplicate it?  Remember, it’s only for generating the starting point!

Below is full demonstration & Code

Demo:

https://www.talkimg.com/images/2025/02/25/q4fzj.gif

---

There’s a big difference between someone posting a youtube tutorial in 2005 and someone introducing an idea at the right time and right place, @Wondrig philosopher didn’t just share information—he brought forward a solution when it was needed the most.

Innovations aren't always about inventing something entirely new; sometimes, they’re about applying knowledge when it is truly needed.

Anyway...

---

Hey Bro, welcome to the black hole! Just a friendly reminder—if you win, I definitely expect an appreciation fee... Fair trade, right?