Lightweight Public Key Database for Brute Force Searching

Just started working on a lightweight database for public keys. Planning to generate billions of keys.

So, the idea is to create a binary file that represents public keys in 0s and 1s. 0s are even, 1s are odd. Pretty straightforward.

If your memory can’t handle all the data, just slice it up. Like, if your limit is 100 million keys, divide it down and manage in chunks.

But dude, be careful with that. If you mess with the last digits, you might end up with invalid private keys.

Yeah, we managed to build a massive database without using tons of disk space. Kinda proud!

What’s the point of this over just storing full public keys, though? Scanning for sequences might take ages without a better structure.

Generating sequences like 01001 is a smart approach. The chances of finding duplicates is super low, right?

But traditional methods also limit your space. If you set a collision margin at 64, you still get faster results, even with a giant database.

Using binary search to split and store keys is a big deal. It cuts down search time significantly when you’re dealing with large datasets.

Remember, storing keys sequentially can mess up efficiency. Just saying.

You’re only keeping binary sequences in a big space to distribute your database evenly. Be strategic about your jumps.

I ran tests with a 35-bit range and 50 million keys. Your low false collision probability doesn’t seem right.

Wait, are you saying there are false positives? If so, just increase that margin! 128 should do it.

Nah, I had good results using 64. Maybe you messed something up. If you changed the code, let’s troubleshoot.

For the 40-bit range, I had zero collisions. What’s the size needed for higher ranges, though? Can we parallelize this work?

Saw your deleted message, but I caught a glimpse. You still don’t see the differences, huh? Knowing the first digit helps a lot.

Stop sharing anything public! No working script should be out there like that. Using 1 bit for keys sounds wild. Imagine storing 100TB with enough power!

You can tweak the parameters to check limits using secp256k1, like you said. There shouldn’t be floats.

I deleted it because I wasn’t sure if it was right. Here’s a potential fix you could try.

Yeah, it’s the jump in subtraction that’s throwing things off, not the collision margin. Trying to fix that.