Bitcoin puzzle transaction ~32 BTC prize to who solves it

[analyticnomad]

Need multiple pubkeys load by file and  search...

Why I never add a list of targets in any of my apps ?

I have a list of about 1000 public keys. All are above 2BTC

Are you trying to brute other peoples keys?

[Benjade]

so I gave up...

This is the first time someone has admitted they don’t know something while working on coding in this topic. Usually, everyone acts like they know everything. 

The pot calling the kettle black ?  

[pbies]

How to edit VanitySearch by JLP to search in puzzle 71 space (not from 1)?

Anybody gone into c/c++ in this project?

Try JLP VanitySearch forked by @allinbit and @Ilker, starting from ranges what you want.
https://github.com/ilkerccom/VanitySearch

I tested it with puzzle 57, give wrong private key generated:

Code:

VanitySearch v1.16 Linux with BitCrack integration
[keyspace] start=                                                 1EB25C907000000
[keyspace]   end=                                                 1EB25C90795DFFF
Difficulty: 1461501637330902918203684832716283019655932542976
Search: 15c9mPGLku1HuW9LRtBf4jcHVpBUt8txKz [Compressed]
Current task START time: Mon May 12 16:13:57 2025
Number of CPU thread: 0
GPU: GPU #0 NVIDIA GeForce RTX 2050 (16x128 cores) Grid(2048x256)
 
Warning, wrong private key generated !
  Addr :15c9mPGLku1HuW9LRtBf4jcHVpBUunRoQS
  Check:1MH9K9aeZNBvLoyRzk2pwfMwygM5hMjwgZ
  Endo:0 incr:540 comp:1
[EXIT] Range research completed (2^36.55) [00:01:06 RUN || END ...finishing][0]  
Current task END time: Mon May 12 16:15:05 2025

I had no problem with other puzzle - it was found properly,
however the output file is not written, if pvk from console will disappear then it will be not written to the file.

[Bram24732]

What’s your Bloomfilter implementation like ? 2.5x seems like a lot ?

My version, which is based on the Keyhunt version, didn’t work with more than 20 targets. What did work was either too slow or buggy, so I gave up on using the Bloomfilter altogether in brute-force puzzle apps.

I’ll add one to your repo when I have a bit of time

[benjaniah]

Need multiple pubkeys load by file and  search...

Why I never add a list of targets in any of my apps ?

I have a list of about 1000 public keys. All are above 2BTC

You should add Satoshi's 34k public keys to your list, each one with 50BTC. Maybe someone can calculate how many RTX-5090's you'd need to crack just one of those wallets in 24 hours? 

https://bitcoin.oni.su/satoshi_public_keys/34K_2009_50.html

[nomachine]

What program was used and how, when people talked about petahash and nomachine did run around eksahash?

Keyhunt in bsgs mode using 64GB bP Table  

P.S. something like this:

Code:

./keyhunt -m bsgs -f tests/135.txt -b 135 -R -n 0x100000000000 -k 4096 -e -q -t 48 -s 10 -S

[fecell]

You should add Satoshi's 34k public keys to your list, each one with 50BTC. Maybe someone can calculate how many RTX-5090's you'd need to crack just one of those wallets in 24 hours? 

how pub keys was gotten, if no one out TX was?!

[user_not_here]

What program was used and how, when people talked about petahash and nomachine did run around eksahash?

Keyhunt in bsgs mode using 64GB bP Table  

P.S. something like this:

Code:

./keyhunt -m bsgs -f tests/135.txt -b 135 -R -n 0x100000000000 -k 4096 -e -q -t 48 -s 10 -S

Thanks, now i remember.

Tested PointSearch, fast..
Miss some range suffle.

[POD5]

Trying Point_Search_RC

So, for puzzle 135 it would be;   

Code:

134
135
25
02145d2611c823a396ef6712ce0f712f09b9b4f3135e3e0aa3230fb9b6d08d1e16

and it goes forwards and backwards?

[Psychedelic Susa]

You should add Satoshi's 34k public keys to your list, each one with 50BTC. Maybe someone can calculate how many RTX-5090's you'd need to crack just one of those wallets in 24 hours? 

how pub keys was gotten, if no one out TX was?!

Pay To Public Key

"outputs": [
    {
      "address": "1Lo1VC2YNkqELDNGHpsKDD8KEzbNKBjzpF",
      "pkscript": "41040000356cb2e0d0c0a0167693b14c338f548da20fea024a04449907140fa270ebff37ae70d00 db8137b5c60d9563b743b090f162f7bf1b51650d20cd7022d695dac",
      "value": 5000000000,
      "spent": false,
      "spender": null
    }
  ],

pkscript = public key

[Nodemath]

Can anyone provide me GPU private key to Hash 160 with c++  call work with Python
600Mkeys/sec
Not like vanity or bit crack
I will release whole new way

Help me out it will decrease whole thing

[Nodemath]

Python code

Under private to hash 160 GPU Using with C++
#Include

Close with python

[nomachine]

CPU version can be improved in many ways(partitioning the space according to number of CPU cores set to use).

Here’s an idea: let’s do Points the same way Cyclone does. If we run this twice. One batch for evens, one for odds. We’ll pull around 120M public keys per second, even on a potato CPU.

Code:

#include <iostream>
#include <fstream>
#include <ctime>
#include <chrono>
#include <vector>
#include <algorithm>
#include <thread>
#include <cmath>
#include <omp.h>

#include "secp256k1/SECP256k1.h"
#include "secp256k1/Int.h"
#include "bloom/filter.hpp"

using namespace std;

// existing utility functions

auto main() -> int {
    Secp256K1* secp256k1 = new Secp256K1(); secp256k1->Init();
    
    Int pk; pk.SetBase10("1");
    uint64_t mult = 2;
    vector<Int> S_table;
    for (int i = 0; i < 256; i++) {
        S_table.push_back(pk);
        pk.Mult(mult);
    }
    print_time(); cout << "S_table generated" << endl;

    uint64_t range_start, range_end, block_width;
    string temp, search_pub;
    ifstream inFile("settings.txt");
    getline(inFile, temp); range_start = str_to_uint64(temp);
    getline(inFile, temp); range_end = str_to_uint64(temp);
    getline(inFile, temp); block_width = str_to_uint64(temp);
    getline(inFile, temp); search_pub = trim(temp);
    inFile.close();
    
    // Load bloom filters
    print_time(); cout << "Loading Bloomfilter bloom1.bf" << endl;
    filter bf1;
    std::ifstream in1("bloom1.bf", std::ios::binary);
    std::size_t c1;
    in1.read((char*) &c1, sizeof(c1));
    bf1.reset(c1);
    boost::span<unsigned char> s1 = bf1.array();
    in1.read((char*) s1.data(), s1.size());
    in1.close();

    print_time(); cout << "Loading Bloomfilter bloom2.bf" << endl;
    filter bf2;
    std::ifstream in2("bloom2.bf", std::ios::binary);
    std::size_t c2;
    in2.read((char*) &c2, sizeof(c2));
    bf2.reset(c2);
    boost::span<unsigned char> s2 = bf2.array();
    in2.read((char*) s2.data(), s2.size());
    in2.close();

    const int POINTS_BATCH_SIZE = 512; // Adjust based on your needs
    
    Int first_scalar, second_scalar, pre_calc_sum;
    first_scalar.Set(&S_table[range_start - 1]);
    second_scalar.Set(&S_table[range_start - 2]);
    pre_calc_sum.Add(&first_scalar, &second_scalar);
    
    auto parallel_search = [&](bool is_addition) {
        string settings_file_even = is_addition ? "settings1_even.txt" : "settings2_even.txt";
        string settings_file_odd = is_addition ? "settings1_odd.txt" : "settings2_odd.txt";
        
        // Even points setup
        string temp, cpub;
        Point starting_point_even, stride_point, calc_point;
        Int stride_sum_even, stride;
        
        ifstream inFileEven(settings_file_even);
        if (inFileEven.good()) {
            getline(inFileEven, temp);
            starting_point_even = secp256k1->ParsePublicKeyHex(trim(temp));
            getline(inFileEven, temp);
            stride_sum_even.SetBase10(trim(temp).data());
            inFileEven.close();
        } else {
            starting_point_even = secp256k1->ComputePublicKey(&pre_calc_sum);
            stride_sum_even.SetInt32(0);
        }
        
        // Odd points setup
        Point starting_point_odd;
        Int stride_sum_odd;
        
        ifstream inFileOdd(settings_file_odd);
        if (inFileOdd.good()) {
            getline(inFileOdd, temp);
            starting_point_odd = secp256k1->ParsePublicKeyHex(trim(temp));
            getline(inFileOdd, temp);
            stride_sum_odd.SetBase10(trim(temp).data());
            inFileOdd.close();
        } else {
            Int odd_key; odd_key.Set(&pre_calc_sum); odd_key.AddOne();
            starting_point_odd = secp256k1->ComputePublicKey(&odd_key);
            stride_sum_odd.SetInt32(0);
        }
        
        stride.SetInt64(uint64_t(pow(2, block_width)));
        stride_point = secp256k1->ScalarMultiplication(&stride);
        
        // Precompute batch points
        std::vector<Point> batchPoints(POINTS_BATCH_SIZE);
        for (int i = 0; i < POINTS_BATCH_SIZE; i++) {
            Int tmp; tmp.SetInt32(i);
            Point p = secp256k1->ScalarMultiplication(&tmp);
            batchPoints[i] = p;
        }
        
        std::vector<Int> deltaX(POINTS_BATCH_SIZE);
        IntGroup modGroup(POINTS_BATCH_SIZE);
        std::vector<Int> pointBatchX(POINTS_BATCH_SIZE);
        std::vector<Int> pointBatchY(POINTS_BATCH_SIZE);
        
        int save_counter_even = 0;
        int save_counter_odd = 0;
        
        while (true) {
            // Process EVEN points
            {
                Point startPoint = starting_point_even;
                Int startPointX, startPointY, startPointXNeg;
                startPointX.Set(&startPoint.x);
                startPointY.Set(&startPoint.y);
                startPointXNeg.Set(&startPointX);
                startPointXNeg.ModNeg();

                // Compute deltaX for batch points
                for (int i = 0; i < POINTS_BATCH_SIZE; i += 4) {
                    deltaX[i].ModSub(&batchPoints[i].x, &startPointX);
                    deltaX[i+1].ModSub(&batchPoints[i+1].x, &startPointX);
                    deltaX[i+2].ModSub(&batchPoints[i+2].x, &startPointX);
                    deltaX[i+3].ModSub(&batchPoints[i+3].x, &startPointX);
                }

                modGroup.Set(deltaX.data());
                modGroup.ModInv();

                // Compute batch points
                for (int i = 0; i < POINTS_BATCH_SIZE; i++) {
                    Int deltaY;
                    deltaY.ModSub(&batchPoints[i].y, &startPointY);
                    Int slope;
                    slope.ModMulK1(&deltaY, &deltaX[i]);
                    Int slopeSq;
                    slopeSq.ModSquareK1(&slope);
                    pointBatchX[i].Set(&startPointXNeg);
                    pointBatchX[i].ModAdd(&slopeSq);
                    pointBatchX[i].ModSub(&batchPoints[i].x);
                    Int diffX;
                    diffX.Set(&startPointX);
                    diffX.ModSub(&pointBatchX[i]);
                    diffX.ModMulK1(&slope);
                    pointBatchY[i].Set(&startPointY);
                    pointBatchY[i].ModNeg();
                    pointBatchY[i].ModAdd(&diffX);
                }

                // Check all points in the batch against bloom filter
                for (int i = 0; i < POINTS_BATCH_SIZE; i++) {
                    Point tempPoint;
                    tempPoint.x.Set(&pointBatchX[i]);
                    tempPoint.y.Set(&pointBatchY[i]);
                    string cpub = secp256k1->GetPublicKeyHex(tempPoint);
                    
                    if (bf1.may_contain(cpub)) {
                        print_time(); cout << "BloomFilter Hit bloom1.bf (Even Point) ["
                                         << (is_addition ? "Lower" : "Higher") << " Range Half]" << endl;
                        
                        Point P(tempPoint);
                        vector<uint64_t> privkey_num;
                        auto pow10_nums = break_down_to_pow10(uint64_t(pow(2, block_width)));
                        vector<Point> pow10_points;
                        Int pow_key;
                        for (auto n : pow10_nums) {
                            pow_key.SetInt64(n);
                            pow10_points.push_back(secp256k1->ScalarMultiplication(&pow_key));
                        }
                        
                        int index = 0;
                        string cpub_check;
                        for (auto p : pow10_points) {
                            int count = 0;
                            cpub_check = secp256k1->GetPublicKeyHex(P);
                            while (bf1.may_contain(cpub_check)) {
                                P = secp256k1->SubtractPoints(P, p);
                                cpub_check = secp256k1->GetPublicKeyHex(P);
                                count += 1;
                            }
                            privkey_num.push_back(pow10_nums[index] * (count - 1));
                            P = secp256k1->AddPoints(P, p);
                            index += 1;
                        }
                        
                        Int Int_steps, Int_temp, privkey;
                        uint64_t steps = 0;
                        for (auto i : privkey_num) { steps += i; }
                        Int_steps.SetInt64(steps);
                        
                        if (is_addition) {
                            Int_temp.Sub(&stride_sum_even, &Int_steps);
                            privkey.Sub(&pre_calc_sum, &Int_temp);
                        } else {
                            Int_temp.Add(&stride_sum_even, &Int_steps);
                            privkey.Add(&pre_calc_sum, &Int_temp);
                        }
                        
                        privkey.Mult(mult);
                        calc_point = secp256k1->ScalarMultiplication(&privkey);
                        if (secp256k1->GetPublicKeyHex(calc_point) == search_pub) {
                            print_time(); cout << "Privatekey: " << privkey.GetBase10() << endl;
                            ofstream outFile;
                            outFile.open("found.txt", ios::app);
                            outFile << privkey.GetBase10() << '\n';
                            outFile.close();
                            exit(0);
                        }
                        print_time(); cout << "False Positive" << endl;
                    }
                }
                
                // Move to next even batch
                if (is_addition) {
                    starting_point_even = secp256k1->AddPoints(starting_point_even, stride_point);
                } else {
                    starting_point_even = secp256k1->SubtractPoints(starting_point_even, stride_point);
                }
                stride_sum_even.Add(&stride);
                
                save_counter_even += POINTS_BATCH_SIZE;
                if (save_counter_even >= 50000000) {
                    cpub = secp256k1->GetPublicKeyHex(starting_point_even);
                    ofstream outFile;
                    outFile.open(settings_file_even);
                    outFile << cpub <<'\n';
                    outFile << stride_sum_even.GetBase10() << '\n';
                    outFile.close();
                    save_counter_even = 0;
                    print_time(); cout << "Save Data written to " << settings_file_even << endl;
                }
            }

            // Process ODD points
            {
                Point startPoint = starting_point_odd;
                Int startPointX, startPointY, startPointXNeg;
                startPointX.Set(&startPoint.x);
                startPointY.Set(&startPoint.y);
                startPointXNeg.Set(&startPointX);
                startPointXNeg.ModNeg();

                // Compute deltaX for batch points
                for (int i = 0; i < POINTS_BATCH_SIZE; i += 4) {
                    deltaX[i].ModSub(&batchPoints[i].x, &startPointX);
                    deltaX[i+1].ModSub(&batchPoints[i+1].x, &startPointX);
                    deltaX[i+2].ModSub(&batchPoints[i+2].x, &startPointX);
                    deltaX[i+3].ModSub(&batchPoints[i+3].x, &startPointX);
                }

                modGroup.Set(deltaX.data());
                modGroup.ModInv();

                // Compute batch points
                for (int i = 0; i < POINTS_BATCH_SIZE; i++) {
                    Int deltaY;
                    deltaY.ModSub(&batchPoints[i].y, &startPointY);
                    Int slope;
                    slope.ModMulK1(&deltaY, &deltaX[i]);
                    Int slopeSq;
                    slopeSq.ModSquareK1(&slope);
                    pointBatchX[i].Set(&startPointXNeg);
                    pointBatchX[i].ModAdd(&slopeSq);
                    pointBatchX[i].ModSub(&batchPoints[i].x);
                    Int diffX;
                    diffX.Set(&startPointX);
                    diffX.ModSub(&pointBatchX[i]);
                    diffX.ModMulK1(&slope);
                    pointBatchY[i].Set(&startPointY);
                    pointBatchY[i].ModNeg();
                    pointBatchY[i].ModAdd(&diffX);
                }

                // Check all points in the batch against bloom filter
                for (int i = 0; i < POINTS_BATCH_SIZE; i++) {
                    Point tempPoint;
                    tempPoint.x.Set(&pointBatchX[i]);
                    tempPoint.y.Set(&pointBatchY[i]);
                    string cpub = secp256k1->GetPublicKeyHex(tempPoint);
                    
                    if (bf2.may_contain(cpub)) {
                        print_time(); cout << "BloomFilter Hit bloom2.bf (Odd Point) ["
                                         << (is_addition ? "Lower" : "Higher") << " Range Half]" << endl;
                        
                        Point P(tempPoint);
                        vector<uint64_t> privkey_num;
                        auto pow10_nums = break_down_to_pow10(uint64_t(pow(2, block_width)));
                        vector<Point> pow10_points;
                        Int pow_key;
                        for (auto n : pow10_nums) {
                            pow_key.SetInt64(n);
                            pow10_points.push_back(secp256k1->ScalarMultiplication(&pow_key));
                        }
                        
                        int index = 0;
                        string cpub_check;
                        for (auto p : pow10_points) {
                            int count = 0;
                            cpub_check = secp256k1->GetPublicKeyHex(P);
                            while (bf2.may_contain(cpub_check)) {
                                P = secp256k1->SubtractPoints(P, p);
                                cpub_check = secp256k1->GetPublicKeyHex(P);
                                count += 1;
                            }
                            privkey_num.push_back(pow10_nums[index] * (count - 1));
                            P = secp256k1->AddPoints(P, p);
                            index += 1;
                        }
                        
                        Int Int_steps, Int_temp, privkey;
                        uint64_t steps = 0;
                        for (auto i : privkey_num) { steps += i; }
                        Int_steps.SetInt64(steps);
                        
                        if (is_addition) {
                            Int_temp.Sub(&stride_sum_odd, &Int_steps);
                            privkey.Sub(&pre_calc_sum, &Int_temp);
                        } else {
                            Int_temp.Add(&stride_sum_odd, &Int_steps);
                            privkey.Add(&pre_calc_sum, &Int_temp);
                        }
                        
                        privkey.Mult(mult);
                        privkey.AddOne(); // Add one for odd points
                        calc_point = secp256k1->ScalarMultiplication(&privkey);
                        if (secp256k1->GetPublicKeyHex(calc_point) == search_pub) {
                            print_time(); cout << "Privatekey: " << privkey.GetBase10() << endl;
                            ofstream outFile;
                            outFile.open("found.txt", ios::app);
                            outFile << privkey.GetBase10() << '\n';
                            outFile.close();
                            exit(0);
                        }
                        print_time(); cout << "False Positive" << endl;
                    }
                }
                
                // Move to next odd batch
                if (is_addition) {
                    starting_point_odd = secp256k1->AddPoints(starting_point_odd, stride_point);
                } else {
                    starting_point_odd = secp256k1->SubtractPoints(starting_point_odd, stride_point);
                }
                stride_sum_odd.Add(&stride);
                
                save_counter_odd += POINTS_BATCH_SIZE;
                if (save_counter_odd >= 50000000) {
                    cpub = secp256k1->GetPublicKeyHex(starting_point_odd);
                    ofstream outFile;
                    outFile.open(settings_file_odd);
                    outFile << cpub <<'\n';
                    outFile << stride_sum_odd.GetBase10() << '\n';
                    outFile.close();
                    save_counter_odd = 0;
                    print_time(); cout << "Save Data written to " << settings_file_odd << endl;
                }
            }
        }
    };
    
    print_time(); cout << "Search in progress with dual while loops..." << endl;
    
    // Launch 2 separate searches:
    // 1. Addition (processing both even and odd)
    // 2. Subtraction (processing both even and odd)
    std::thread thread1([&]() { parallel_search(true); });   // Addition
    std::thread thread2([&]() { parallel_search(false); });  // Subtraction
    
    thread1.join();
    thread2.join();
}

P.S. This is just a draft of what the code should look like.

[Akito S. M. Hosana]

We’ll pull around 120M public keys per second, even on a potato CPU.

Code:

    thread1.join();
    thread2.join();
}

P.S. This is just a draft of what the code should look like.

Super tough with just 2 threads. Gotta use at least 12 on my CPU. Probably something like #pragma omp parallel num_threads(numCPUs) from Cyclone… But yeah, looks like this is just a draft. 

I'll ask AI to do this for me. 

[nomachine]

I'll ask AI to do this for me. 

LMAO. Do whatever you want, but don’t complain later if it doesn’t work. You’ll get trash idiotic code. At best, it’ll suggest switching to OpenSSL because that’s easier for the AI. It can’t comprehend someone breaking down Point operations into low-level batched optimizations using modGroup, ModNeg, ModInv, ModAdd, ModSub, ModMulK1, and ModSquareK1.  

[Akito S. M. Hosana]

I'll ask AI to do this for me. 

LMAO. Do whatever you want, but don’t complain later if it doesn’t work. You’ll get trash idiotic code. At best, it’ll suggest switching to OpenSSL because that’s easier for the AI. It can’t comprehend someone breaking down Point operations into low-level batched optimizations using modGroup, ModNeg, ModInv, ModAdd, ModSub, ModMulK1, and ModSquareK1.  

Wait, this can also be done in Cyclone? To divide batch operations into evens and odds. Isn't it?

[nomachine]

Wait, this can also be done in Cyclone? To divide batch operations into evens and odds. Isn't it?

It can be done in any program that works based on JLP. Only if you know how.  

P.S. You can also add #include "bloom/filter.hpp" to Cyclone, but you must state that the idea was taken from AlexanderCurl's Git repository. 

[Akito S. M. Hosana]

You can also add #include "bloom/filter.hpp" to Cyclone, but you must state that the idea was taken from AlexanderCurl's Git repository. 

This is too complex an operation for AI. 

[POD5]

And moreover if you have some interesing ideas or questions you can always contact me on telegram.

Yeahh, I remember those days, and then you were gone.  
I'll keep using Cyclone, but your code is always intersting.

[nomachine]

Both Cyclone and Mutagen updated.

https://github.com/NoMachine1/Cyclone

https://github.com/NoMachine1/Mutagen