Bitcoin puzzle transaction ~32 BTC prize to who solves it

[albert0bsd]

No more 66, just played with it for a while  but have some 10 character 68 for whatever you are experimenting with. Also these addresses have not been checked for possible balance. Good luck.

Seems that sha256 and rmd160 is a joke for most users here, all those partial address are not useful at all.

[1715346366]

1715346366

[1715346366]

1715346366

[1715346366]

1715346366

[unclevito]

No more 66, just played with it for a while  but have some 10 character 68 for whatever you are experimenting with. Also these addresses have not been checked for possible balance. Good luck.

Seems that sha256 and rmd160 is a joke for most users here, all those partial address are not useful at all.

They have some idea so it does not hurt for them to try.

[_Counselor]

Seems that sha256 and rmd160 is a joke for most users here, all those partial address are not useful at all.

With a high level of entropy that sha256+rmd160 provides, I would say that from a mathematical point of view, the desired address is quite far from addresses starting with similar letters. Therefore, in theory, we can exclude some ranges from search where addresses with similar prefixes was found. But anyway the real random is the kind of thing from which you can expect anything.

[7isce]

Seems that sha256 and rmd160 is a joke for most users here, all those partial address are not useful at all.

I agree with that. Some people think the processes inside sha256 and rmd160 are based on scientific steps but they are wrong.
It's based on what we called "BLACK MAGIC", You do the steps in certain way and you get your target output(Here is UNIQUENESS) without any scientific explanation on why you do it in this order or why you use this operation instead of that operation...

BLACK MAGIC != SCIENCE

[digaran]

Seems that sha256 and rmd160 is a joke for most users here, all those partial address are not useful at all.

I agree with that. Some people think the processes inside sha256 and rmd160 are based on scientific steps but they are wrong.
It's based on what we called "BLACK MAGIC", You do the steps in certain way and you get your target output(Here is UNIQUENESS) without any scientific explanation on why you do it in this order or why you use this operation instead of that operation...

BLACK MAGIC != SCIENCE

Is there any voodoo priest here? I have some questions about some of the rituals involved in sha256 and rmd160.

I was wondering, what if we design an elliptic curve that has a fixed 64 characters public keys and then we could skip sha256 hashing and go directly to rmd160 hashing?

This would have zero relevance to secp256k1 curve, I just wanted to know if it's possible, which I assume it is, since I know no black magic, I thought to ask here.😉

[nomachine]

This would have zero relevance to secp256k1 curve, I just wanted to know if it's possible, which I assume it is, since I know no black magic, I thought to ask here.😉

Addresses with private keys and public addresses will not match. It doesn't matter if you reach 10B addresses per second if they are not in the BTC Bitcoin network.
it's certainly possible to do so, but it would be in a separate context from Bitcoin and would not be suitable for use within the Bitcoin network.  

Next level of  voodoo would be be optimizing SHA-256 and RIPEMD-160 hashing more  reducing redundant operations and utilizing efficient libraries or algorithms.
Or even making specialized hardware for them with special instructions.

We're struggling more with hardware than math here.

[digaran]

It's an idea to use compressed public keys without 02, 03 and hash them with only rmd160, it could help in finding collisions. Nvm this one.

@Satoshi, are you up for this challenge?
https://bitcointalk.org/index.php?topic=5462186.0

It could have a small amount to test such a challenge, I am saying this because many people have doubts about the specified ranges of the current challenge, since there is a way to prove whether a key is in a certain range, why not put it into test, of course if you think it's useful to have such a puzzle.

If it is and you decide to design one, please do share the details in this thread or the other puzzle thread. Thank you on behalf of everyone here.

Ps, I don't have spare coins, otherwise I would do it myself. I think I might have some ideas how to solve a key in a proven range, but it requires many GPUs.

[mcdouglasx]

This would have zero relevance to secp256k1 curve, I just wanted to know if it's possible, which I assume it is, since I know no black magic, I thought to ask here.😉

Addresses with private keys and public addresses will not match. It doesn't matter if you reach 10B addresses per second if they are not in the BTC Bitcoin network.
it's certainly possible to do so, but it would be in a separate context from Bitcoin and would not be suitable for use within the Bitcoin network.  

Next level of  voodoo would be be optimizing SHA-256 and RIPEMD-160 hashing more  reducing redundant operations and utilizing efficient libraries or algorithms.
Or even making specialized hardware for them with special instructions.

We're struggling more with hardware than math here.

The addresses are valid for bitcoin, but results in addresses with unknown private keys.

[nomachine]

Hello everyone, and especially those who still remember me)
Has anyone used OpenSSL to generate keys?
Probably not..

main.cpp (*Int class require some code changes within the SECP256k1 library to support BIGNUM* directly.)


Yes...

But it is still slow. Even 5M keys/s per core muscles is not enough for such a large range.

hi there nomachine, is there a compiled exe there.. or not. thanks man

I have solution for Linux now. I have no idea how this can work on Windows - I haven't had it in years. It is about 5-6 M keys/s per core brute force script.

Code:

sudo apt update && sudo apt install libssl-dev

Code:

git clone https://github.com/JeanLucPons/VanitySearch.git

Change in that folder main.cpp to be:

Code:

#include "SECP256k1.h"
#include "Int.h"
#include <iostream>
#include <fstream>
#include <string>
#include <ctime>
#include <iomanip>
#include <sstream>
#include <thread>
#include <vector>
#include <mutex>
#include <memory>
#include <openssl/bn.h>

const int numThreads = 12; // You can adjust this number based on your CPU cores

// Function to generate a random private key using BIGNUM
BIGNUM* generateRandomPrivateKey(const BIGNUM* minKey, const BIGNUM* maxKey) {
    BIGNUM* randomPrivateKey = BN_new();
    BIGNUM* range = BN_new();

    // Calculate the range (maxKey - minKey)
    BN_sub(range, maxKey, minKey);

    // Generate a random number in the range [0, range)
    BN_rand_range(randomPrivateKey, range);

    // Add the minimum value to the generated random number
    BN_add(randomPrivateKey, randomPrivateKey, minKey);

    // Cleanup the range BIGNUM
    BN_free(range);

    return randomPrivateKey;
}

// Function to convert a BIGNUM to Int
Int bignumToBigInt(const BIGNUM* bignum) {
    char* bignumStr = BN_bn2dec(bignum);
    Int bigInt;
    bigInt.SetBase10(bignumStr);
    OPENSSL_free(bignumStr);
    return bigInt;
}

// Function to generate keys and check for a specific address
void generateKeysAndCheckForAddress(BIGNUM* minKey, BIGNUM* maxKey, std::shared_ptr<Secp256K1> secp256k1, const std::string& targetAddress) {
    while (true) {
        BIGNUM* randomPrivateKey = generateRandomPrivateKey(minKey, maxKey);

        // Convert the BIGNUM private key to an Int
        Int privateKey = bignumToBigInt(randomPrivateKey);

        // Continue with the rest of the address generation and checking logic
        Point publicKey;
        std::string caddr;
        std::string wifc;

        publicKey = secp256k1->ComputePublicKey(&privateKey);
        caddr = secp256k1->GetAddress(0, true, publicKey);
        wifc = secp256k1->GetPrivAddress(true, privateKey);

        // Display the generated address
        std::string message = "\r\033[01;33m[+] " + caddr;
        std::cout << message << "\e[?25l";
        std::cout.flush();

        // Check if the generated address matches the target address
        if (caddr.find(targetAddress) != std::string::npos) {
            time_t currentTime = std::time(nullptr);

            // Format the current time into a human-readable string
            std::tm tmStruct = *std::localtime(&currentTime);
            std::stringstream timeStringStream;
            timeStringStream << std::put_time(&tmStruct, "%Y-%m-%d %H:%M:%S");
            std::string formattedTime = timeStringStream.str();

            std::cout << "\n\033[32m[+] PUZZLE SOLVED: " << formattedTime << "\033[0m" << std::endl;
            std::cout << "\033[32m[+] WIF: " << wifc << "\033[0m" << std::endl;

            // Append the private key information to a file if it matches
            std::ofstream file("KEYFOUNDKEYFOUND.txt", std::ios::app);
            if (file.is_open()) {
                file << "\nPUZZLE SOLVED " << formattedTime;
                file << "\nPublic Address Compressed: " << caddr;
                file << "\nPrivatekey (dec): " << privateKey.GetBase10();
                file << "\nPrivatekey Compressed (wif): " << wifc;
                file << "\n----------------------------------------------------------------------------------------------------------------------------------";
                file.close();
            }

            // Free the BIGNUM and break the loop
            BN_free(randomPrivateKey);
            break;
        }

        // Free the BIGNUM immediately
        BN_free(randomPrivateKey);

        // Convert the max key to an Int
        Int maxInt;
        maxInt.SetBase10(BN_bn2dec(maxKey));

        if (privateKey.IsGreater(&maxInt)) {
            break;
        }
    }
}

int main() {
    // Clear the console
    std::system("clear");

    time_t currentTime = std::time(nullptr);
    std::cout << "\033[01;33m[+] " << std::ctime(&currentTime) << "\r";
    std::cout.flush();

    BIGNUM* minKeyBN = BN_new(); // Initialize minKeyBN
    BIGNUM* maxKeyBN = BN_new(); // Initialize maxKeyBN

    // Configuration for the Puzzle
    // Set minKeyBN and maxKeyBN using the provided base 10 values
    BN_dec2bn(&minKeyBN, "30568377312063203855");
    BN_dec2bn(&maxKeyBN, "30568377312065203855");
    std::string targetAddress = "18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe";

    // Initialize SECP256k1
    std::shared_ptr<Secp256K1> secp256k1 = std::make_shared<Secp256K1>();
    secp256k1->Init();

    // Create threads for key generation and checking
    std::vector<std::thread> threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(generateKeysAndCheckForAddress, minKeyBN, maxKeyBN, secp256k1, targetAddress);
    }

    // Wait for all threads to finish
    for (std::thread& thread : threads) {
        thread.join();
    }

    // Cleanup BIGNUM variables
    BN_free(minKeyBN);
    BN_free(maxKeyBN);

    return 0;
}

Change Makefile to be:

Code:

SRC = Base58.cpp IntGroup.cpp main.cpp Random.cpp Timer.cpp \
      Int.cpp IntMod.cpp Point.cpp SECP256K1.cpp \
      hash/ripemd160.cpp hash/sha256.cpp hash/sha512.cpp \
      hash/ripemd160_sse.cpp hash/sha256_sse.cpp Bech32.cpp

OBJDIR = obj

OBJET = $(addprefix $(OBJDIR)/, \
        Base58.o IntGroup.o main.o Random.o Int.o Timer.o \
        IntMod.o Point.o SECP256K1.o \
        hash/ripemd160.o hash/sha256.o hash/sha512.o \
        hash/ripemd160_sse.o hash/sha256_sse.o Bech32.o)

CXX = g++
CXXFLAGS = -m64 -mssse3 -Wno-write-strings -O3 -I.

LFLAGS = -lpthread -lssl -lcrypto

$(OBJDIR)/%.o : %.cpp
	$(CXX) $(CXXFLAGS) -o $@ -c $<



VanitySearch: $(OBJET)
	@echo Making Lottery...
	$(CXX) $(OBJET) $(LFLAGS) -o LOTTO.bin && chmod +x LOTTO.bin

$(OBJET): | $(OBJDIR) $(OBJDIR)/hash

$(OBJDIR):
	mkdir -p $(OBJDIR)

$(OBJDIR)/hash: $(OBJDIR)
	cd $(OBJDIR) &&	mkdir -p hash

clean:
	@echo Cleaning...
	@rm -f obj/*.o
	@rm -f obj/hash/*.o

Code:

make

and  start

Code:

 ./LOTTO.bin

Good luck

[mcdouglasx]

Hello everyone, and especially those who still remember me)
Has anyone used OpenSSL to generate keys?
Probably not..

main.cpp (*Int class require some code changes within the SECP256k1 library to support BIGNUM* directly.)


Yes...

But it is still slow. Even 5M keys/s per core muscles is not enough for such a large range.

hi there nomachine, is there a compiled exe there.. or not. thanks man

I have solution for Linux now. I have no idea how this can work on Windows - I haven't had it in years. It is about 5-6 M keys/s per core brute force script.

Code:

sudo apt update && sudo apt install libssl-dev

Code:

git clone https://github.com/JeanLucPons/VanitySearch.git

Change in that folder main.cpp to be:

Code:

#include "SECP256k1.h"
#include "Int.h"
#include <iostream>
#include <fstream>
#include <string>
#include <ctime>
#include <iomanip>
#include <sstream>
#include <thread>
#include <vector>
#include <mutex>
#include <memory>
#include <openssl/bn.h>

const int numThreads = 128; // You can adjust this number based on your CPU cores

// Function to generate a random private key using BIGNUM
BIGNUM* generateRandomPrivateKey(const BIGNUM* minKey, const BIGNUM* maxKey) {
    BIGNUM* randomPrivateKey = BN_new();
    BN_rand_range(randomPrivateKey, maxKey);

    // Ensure the generated key is within the desired range
    while (BN_cmp(randomPrivateKey, minKey) < 0) {
        BN_rand_range(randomPrivateKey, maxKey);
    }

    return randomPrivateKey;
}

// Function to convert a BIGNUM to Int
Int bignumToBigInt(const BIGNUM* bignum) {
    char* bignumStr = BN_bn2dec(bignum);
    Int bigInt;
    bigInt.SetBase10(bignumStr);
    OPENSSL_free(bignumStr);
    return bigInt;
}

// Function to generate keys and check for a specific address
void generateKeysAndCheckForAddress(BIGNUM* minKey, BIGNUM* maxKey, std::shared_ptr<Secp256K1> secp256k1, const std::string& targetAddress) {
    while (true) {
        BIGNUM* randomPrivateKey = generateRandomPrivateKey(minKey, maxKey);

        // Convert the BIGNUM private key to an Int
        Int privateKey = bignumToBigInt(randomPrivateKey);

        // Continue with the rest of the address generation and checking logic
        Point publicKey;
        std::string caddr;
        std::string wifc;

        publicKey = secp256k1->ComputePublicKey(&privateKey);
        caddr = secp256k1->GetAddress(0, true, publicKey);
        wifc = secp256k1->GetPrivAddress(true, privateKey);

        // Display the generated address
        std::string message = "\r\033[01;33m[+] " + caddr;
        std::cout << message << "\e[?25l";
        std::cout.flush();

        // Check if the generated address matches the target address
        if (caddr.find(targetAddress) != std::string::npos) {
            time_t currentTime = std::time(nullptr);

            // Format the current time into a human-readable string
            std::tm tmStruct = *std::localtime(&currentTime);
            std::stringstream timeStringStream;
            timeStringStream << std::put_time(&tmStruct, "%Y-%m-%d %H:%M:%S");
            std::string formattedTime = timeStringStream.str();

            std::cout << "\n\033[32m[+] PUZZLE SOLVED: " << formattedTime << "\033[0m" << std::endl;
            std::cout << "\033[32m[+] WIF: " << wifc << "\033[0m" << std::endl;

            // Append the private key information to a file if it matches
            std::ofstream file("KEYFOUNDKEYFOUND.txt", std::ios::app);
            if (file.is_open()) {
                file << "\nPUZZLE SOLVED " << formattedTime;
                file << "\nPublic Address Compressed: " << caddr;
                file << "\nPrivatekey (dec): " << privateKey.GetBase10();
                file << "\nPrivatekey Compressed (wif): " << wifc;
                file << "\n----------------------------------------------------------------------------------------------------------------------------------";
                file.close();
            }

            // Free the BIGNUM and break the loop
            BN_free(randomPrivateKey);
            break;
        }

        // Free the BIGNUM
        BN_free(randomPrivateKey);

        // Convert the max key to an Int
        Int maxInt;
        maxInt.SetBase10(BN_bn2dec(maxKey));

        if (privateKey.IsGreater(&maxInt)) {
            break;
        }
    }
}


int main() {
    // Clear the console
    std::system("clear");

    time_t currentTime = std::time(nullptr);
    std::cout << "\033[01;33m[+] " << std::ctime(&currentTime) << "\r";
    std::cout.flush();

    BIGNUM* minKeyBN = BN_new(); // Initialize minKeyBN
    BIGNUM* maxKeyBN = BN_new(); // Initialize maxKeyBN

    // Configuration for the Puzzle
    // Set minKeyBN and maxKeyBN using the provided base 10 values
    BN_dec2bn(&minKeyBN, "62079069358943824031");
    BN_dec2bn(&maxKeyBN, "67079069358943924031");
    std::string targetAddress = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so";

    // Initialize SECP256k1
    std::shared_ptr<Secp256K1> secp256k1 = std::make_shared<Secp256K1>();
    secp256k1->Init();

    // Create threads for key generation and checking
    std::vector<std::thread> threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(generateKeysAndCheckForAddress, minKeyBN, maxKeyBN, secp256k1, targetAddress);
    }

    // Wait for all threads to finish
    for (std::thread& thread : threads) {
        thread.join();
    }

    // Cleanup BIGNUM variables
    BN_free(minKeyBN);
    BN_free(maxKeyBN);

    return 0;
}

Change Makefile to be:

Code:

SRC = Base58.cpp IntGroup.cpp main.cpp Random.cpp Timer.cpp \
      Int.cpp IntMod.cpp Point.cpp SECP256K1.cpp \
      hash/ripemd160.cpp hash/sha256.cpp hash/sha512.cpp \
      hash/ripemd160_sse.cpp hash/sha256_sse.cpp Bech32.cpp

OBJDIR = obj

OBJET = $(addprefix $(OBJDIR)/, \
        Base58.o IntGroup.o main.o Random.o Int.o Timer.o \
        IntMod.o Point.o SECP256K1.o \
        hash/ripemd160.o hash/sha256.o hash/sha512.o \
        hash/ripemd160_sse.o hash/sha256_sse.o Bech32.o)

CXX = g++
CXXFLAGS = -m64 -mssse3 -Wno-write-strings -O2 -I.

LFLAGS = -lpthread -lssl -lcrypto

$(OBJDIR)/%.o : %.cpp
	$(CXX) $(CXXFLAGS) -o $@ -c $<



VanitySearch: $(OBJET)
	@echo Making Lottery...
	$(CXX) $(OBJET) $(LFLAGS) -o LOTTO.bin && chmod +x LOTTO.bin

$(OBJET): | $(OBJDIR) $(OBJDIR)/hash

$(OBJDIR):
	mkdir -p $(OBJDIR)

$(OBJDIR)/hash: $(OBJDIR)
	cd $(OBJDIR) &&	mkdir -p hash

clean:
	@echo Cleaning...
	@rm -f obj/*.o
	@rm -f obj/hash/*.o

Code:

make

and  start

Code:

 ./LOTTO.bin

Good luck

For Windows, I suppose you can try to compile it with msys2 and mingw, installing the toolchain with Pacman, or with Cygwin to avoid errors regarding Linux commands in Windows.

[nomachine]

Hello everyone, and especially those who still remember me)
Has anyone used OpenSSL to generate keys?
Probably not..

main.cpp (*Int class require some code changes within the SECP256k1 library to support BIGNUM* directly.)


Yes...

But it is still slow. Even 5M keys/s per core muscles is not enough for such a large range.

hi there nomachine, is there a compiled exe there.. or not. thanks man

I have solution for Linux now. I have no idea how this can work on Windows - I haven't had it in years. It is about 5-6 M keys/s per core brute force script.

Code:

sudo apt update && sudo apt install libssl-dev

Code:

git clone https://github.com/JeanLucPons/VanitySearch.git

Change in that folder main.cpp to be:

Code:

#include "SECP256k1.h"
#include "Int.h"
#include <iostream>
#include <fstream>
#include <string>
#include <ctime>
#include <iomanip>
#include <sstream>
#include <thread>
#include <vector>
#include <mutex>
#include <memory>
#include <openssl/bn.h>

const int numThreads = 128; // You can adjust this number based on your CPU cores

// Function to generate a random private key using BIGNUM
BIGNUM* generateRandomPrivateKey(const BIGNUM* minKey, const BIGNUM* maxKey) {
    BIGNUM* randomPrivateKey = BN_new();
    BN_rand_range(randomPrivateKey, maxKey);

    // Ensure the generated key is within the desired range
    while (BN_cmp(randomPrivateKey, minKey) < 0) {
        BN_rand_range(randomPrivateKey, maxKey);
    }

    return randomPrivateKey;
}

// Function to convert a BIGNUM to Int
Int bignumToBigInt(const BIGNUM* bignum) {
    char* bignumStr = BN_bn2dec(bignum);
    Int bigInt;
    bigInt.SetBase10(bignumStr);
    OPENSSL_free(bignumStr);
    return bigInt;
}

// Function to generate keys and check for a specific address
void generateKeysAndCheckForAddress(BIGNUM* minKey, BIGNUM* maxKey, std::shared_ptr<Secp256K1> secp256k1, const std::string& targetAddress) {
    while (true) {
        BIGNUM* randomPrivateKey = generateRandomPrivateKey(minKey, maxKey);

        // Convert the BIGNUM private key to an Int
        Int privateKey = bignumToBigInt(randomPrivateKey);

        // Continue with the rest of the address generation and checking logic
        Point publicKey;
        std::string caddr;
        std::string wifc;

        publicKey = secp256k1->ComputePublicKey(&privateKey);
        caddr = secp256k1->GetAddress(0, true, publicKey);
        wifc = secp256k1->GetPrivAddress(true, privateKey);

        // Display the generated address
        std::string message = "\r\033[01;33m[+] " + caddr;
        std::cout << message << "\e[?25l";
        std::cout.flush();

        // Check if the generated address matches the target address
        if (caddr.find(targetAddress) != std::string::npos) {
            time_t currentTime = std::time(nullptr);

            // Format the current time into a human-readable string
            std::tm tmStruct = *std::localtime(&currentTime);
            std::stringstream timeStringStream;
            timeStringStream << std::put_time(&tmStruct, "%Y-%m-%d %H:%M:%S");
            std::string formattedTime = timeStringStream.str();

            std::cout << "\n\033[32m[+] PUZZLE SOLVED: " << formattedTime << "\033[0m" << std::endl;
            std::cout << "\033[32m[+] WIF: " << wifc << "\033[0m" << std::endl;

            // Append the private key information to a file if it matches
            std::ofstream file("KEYFOUNDKEYFOUND.txt", std::ios::app);
            if (file.is_open()) {
                file << "\nPUZZLE SOLVED " << formattedTime;
                file << "\nPublic Address Compressed: " << caddr;
                file << "\nPrivatekey (dec): " << privateKey.GetBase10();
                file << "\nPrivatekey Compressed (wif): " << wifc;
                file << "\n----------------------------------------------------------------------------------------------------------------------------------";
                file.close();
            }

            // Free the BIGNUM and break the loop
            BN_free(randomPrivateKey);
            break;
        }

        // Free the BIGNUM
        BN_free(randomPrivateKey);

        // Convert the max key to an Int
        Int maxInt;
        maxInt.SetBase10(BN_bn2dec(maxKey));

        if (privateKey.IsGreater(&maxInt)) {
            break;
        }
    }
}


int main() {
    // Clear the console
    std::system("clear");

    time_t currentTime = std::time(nullptr);
    std::cout << "\033[01;33m[+] " << std::ctime(&currentTime) << "\r";
    std::cout.flush();

    BIGNUM* minKeyBN = BN_new(); // Initialize minKeyBN
    BIGNUM* maxKeyBN = BN_new(); // Initialize maxKeyBN

    // Configuration for the Puzzle
    // Set minKeyBN and maxKeyBN using the provided base 10 values
    BN_dec2bn(&minKeyBN, "62079069358943824031");
    BN_dec2bn(&maxKeyBN, "67079069358943924031");
    std::string targetAddress = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so";

    // Initialize SECP256k1
    std::shared_ptr<Secp256K1> secp256k1 = std::make_shared<Secp256K1>();
    secp256k1->Init();

    // Create threads for key generation and checking
    std::vector<std::thread> threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(generateKeysAndCheckForAddress, minKeyBN, maxKeyBN, secp256k1, targetAddress);
    }

    // Wait for all threads to finish
    for (std::thread& thread : threads) {
        thread.join();
    }

    // Cleanup BIGNUM variables
    BN_free(minKeyBN);
    BN_free(maxKeyBN);

    return 0;
}

Change Makefile to be:

Code:

SRC = Base58.cpp IntGroup.cpp main.cpp Random.cpp Timer.cpp \
      Int.cpp IntMod.cpp Point.cpp SECP256K1.cpp \
      hash/ripemd160.cpp hash/sha256.cpp hash/sha512.cpp \
      hash/ripemd160_sse.cpp hash/sha256_sse.cpp Bech32.cpp

OBJDIR = obj

OBJET = $(addprefix $(OBJDIR)/, \
        Base58.o IntGroup.o main.o Random.o Int.o Timer.o \
        IntMod.o Point.o SECP256K1.o \
        hash/ripemd160.o hash/sha256.o hash/sha512.o \
        hash/ripemd160_sse.o hash/sha256_sse.o Bech32.o)

CXX = g++
CXXFLAGS = -m64 -mssse3 -Wno-write-strings -O2 -I.

LFLAGS = -lpthread -lssl -lcrypto

$(OBJDIR)/%.o : %.cpp
	$(CXX) $(CXXFLAGS) -o $@ -c $<



VanitySearch: $(OBJET)
	@echo Making Lottery...
	$(CXX) $(OBJET) $(LFLAGS) -o LOTTO.bin && chmod +x LOTTO.bin

$(OBJET): | $(OBJDIR) $(OBJDIR)/hash

$(OBJDIR):
	mkdir -p $(OBJDIR)

$(OBJDIR)/hash: $(OBJDIR)
	cd $(OBJDIR) &&	mkdir -p hash

clean:
	@echo Cleaning...
	@rm -f obj/*.o
	@rm -f obj/hash/*.o

Code:

make

and  start

Code:

 ./LOTTO.bin

Good luck

For Windows, I suppose you can try to compile it with msys2 and mingw, installing the toolchain with Pacman, or with Cygwin to avoid errors regarding Linux commands in Windows.

Probably so. I haven't done that in a long time.

I edited the script in the last post. it didn’t want to work on small ranges.

Code:

// Function to generate a random private key using BIGNUM
BIGNUM* generateRandomPrivateKey(const BIGNUM* minKey, const BIGNUM* maxKey) {
    BIGNUM* randomPrivateKey = BN_new();
    BIGNUM* range = BN_new();

    // Calculate the range (maxKey - minKey)
    BN_sub(range, maxKey, minKey);

    // Generate a random number in the range [0, range)
    BN_rand_range(randomPrivateKey, range);

    // Add the minimum value to the generated random number
    BN_add(randomPrivateKey, randomPrivateKey, minKey);

    // Cleanup the range BIGNUM
    BN_free(range);

    return randomPrivateKey;
}

Now will start on a small  range. Let's say
    // Configuration for the Puzzle
    // Set minKeyBN and maxKeyBN using the provided base 10 values
    BN_dec2bn(&minKeyBN, "30568377312063203855");
    BN_dec2bn(&maxKeyBN, "30568377312065203855");
    std::string targetAddress = "18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe";


This is how  looks when hits

• Fri Sep 29 18:01:54 2023
• 18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe
• PUZZLE SOLVED: 2023-09-29 18:02:59
• WIF: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZM21gaY8WN2CdwnTG57

[digaran]

Hey guys, can anyone change the following script to do division either by odd numbers or even numbers?

For example, we set a range of 1:32, it would divide only by 3, 5, 7, 9......31.  Or by 2, 4, 6, 8......32.  Can this be done?
Or even the ability to divide one target by odd numbers and the other target by even numbers.

Code:

# Define the EllipticCurve class
class EllipticCurve:
    def __init__(self, a, b, p):
        self.a = a
        self.b = b
        self.p = p

    def contains(self, point):
        x, y = point.x, point.y
        return (y * y) % self.p == (x * x * x + self.a * x + self.b) % self.p

    def __str__(self):
        return f"y^2 = x^3 + {self.a}x + {self.b} mod {self.p}"

# Define the Point class
class Point:
    def __init__(self, x, y, curve):
        self.x = x
        self.y = y
        self.curve = curve

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y and self.curve == other.curve

    def __ne__(self, other):
        return not self == other

    def __add__(self, other):
        if self.curve != other.curve:
            raise ValueError("Cannot add points on different curves")

        # Case when one point is zero
        if self == Point.infinity(self.curve):
            return other
        if other == Point.infinity(self.curve):
            return self

        if self.x == other.x and self.y != other.y:
            return Point.infinity(self.curve)

        p = self.curve.p
        s = 0
        if self == other:
            s = ((3 * self.x * self.x + self.curve.a) * pow(2 * self.y, -1, p)) % p
        else:
            s = ((other.y - self.y) * pow(other.x - self.x, -1, p)) % p

        x = (s * s - self.x - other.x) % p
        y = (s * (self.x - x) - self.y) % p

        return Point(x, y, self.curve)

    def __sub__(self, other):
        if self.curve != other.curve:
            raise ValueError("Cannot subtract points on different curves")

        # Case when one point is zero
        if self == Point.infinity(self.curve):
            return other
        if other == Point.infinity(self.curve):
            return self

        return self + Point(other.x, (-other.y) % self.curve.p, self.curve)

    def __mul__(self, n):
        if not isinstance(n, int):
            raise ValueError("Multiplication is defined for integers only")

        n = n % (self.curve.p - 1)
        res = Point.infinity(self.curve)
        addend = self

        while n:
            if n & 1:
                res += addend

            addend += addend
            n >>= 1

        return res

    def __str__(self):
        return f"({self.x}, {self.y}) on {self.curve}"

    @staticmethod
    def from_hex(s, curve):
        if len(s) == 66 and s.startswith("02") or s.startswith("03"):
            compressed = True
        elif len(s) == 130 and s.startswith("04"):
            compressed = False
        else:
            raise ValueError("Hex string is not a valid compressed or uncompressed point")

        if compressed:
            is_odd = s.startswith("03")
            x = int(s[2:], 16)

            # Calculate y-coordinate from x and parity bit
            y_square = (x * x * x + curve.a * x + curve.b) % curve.p
            y = pow(y_square, (curve.p + 1) // 4, curve.p)
            if is_odd != (y & 1):
                y = -y % curve.p

            return Point(x, y, curve)
        else:
            s_bytes = bytes.fromhex(s)
            uncompressed = s_bytes[0] == 4
            if not uncompressed:
                raise ValueError("Only uncompressed or compressed points are supported")

            num_bytes = len(s_bytes) // 2
            x_bytes = s_bytes[1 : num_bytes + 1]
            y_bytes = s_bytes[num_bytes + 1 :]

            x = int.from_bytes(x_bytes, byteorder="big")
            y = int.from_bytes(y_bytes, byteorder="big")

            return Point(x, y, curve)

    def to_hex(self, compressed=True):
        if self.x is None and self.y is None:
            return "00"
        elif compressed:
            prefix = "03" if self.y & 1 else "02"
            return prefix + hex(self.x)[2:].zfill(64)
        else:
            x_hex = hex(self.x)[2:].zfill(64)
            y_hex = hex(self.y)[2:].zfill(64)
            return "04" + x_hex + y_hex

    @staticmethod
    def infinity(curve):
        return Point(None, None, curve)

# Define the ec_mul function
def ec_mul(point, scalar, base_point):
    result = Point.infinity(point.curve)
    addend = point

    while scalar:
        if scalar & 1:
            result += addend

        addend += addend
        scalar >>= 1

    return result

# Define the ec_operations function
def ec_operations(start_range, end_range, target_1, target_2, curve):
    # Define parameters for secp256k1 curve
    n = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
    G = Point(
        0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
        0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8,
        curve
    )

    # Open the files for writing
    with open("target1_division_results.txt", "a") as file1, \
            open("target2_division_results.txt", "a") as file2, \
            open("subtract_results.txt", "a") as file3:

        for i in range(start_range, end_range + 1):
            try:
                # Compute the inverse of i modulo n
                i_inv = pow(i, n-2, n)

                # Divide the targets by i modulo n
                result_1 = ec_mul(target_1, i_inv, G)
                result_2 = ec_mul(target_2, i_inv, G)

                # Subtract the results
                sub_result = result_2 - result_1

                # Write the results to separate files
                file1.write(f"{result_1.to_hex()}\n")
                file2.write(f"{result_2.to_hex()}\n")
                file3.write(f"Subtracting results for {i}:\n")
                file3.write(f"Target 1 / {i}: {result_1.to_hex()}\n")
                file3.write(f"Target 2 / {i}: {result_2.to_hex()}\n")
                file3.write(f"Subtraction: {sub_result.to_hex()}\n")
                file3.write("="*50 + "\n")

                print(f"Completed calculation for divisor {i}")
            except ZeroDivisionError:
                print(f"Error: division by zero for {i}")

    print("Calculation completed. Results saved in separate files.")

if __name__ == "__main__":
    # Set the targets and range for the operations
    curve = EllipticCurve(0, 7, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
    target_1 = Point.from_hex("0230210C23B1A047BC9BDBB13448E67DEDDC108946DE6DE639BCC75D47C0216B1B", curve)
    target_2 = Point.from_hex("02F6B787195159544330085C6014DBA627FF5B14F3203FF05D12482F76261F4FC3", curve)
    start_range = 2
    end_range = 10

    ec_operations(start_range, end_range, target_1, target_2, curve)

I rather hear your whining than to deal with AI, it takes 1 day of my time for each script, lol.


Edit: the whining like old ladies started already, @citb0in, trouble in paradise?  Nobody asked you for help, you can't provide it anyways.

If I wanted to "achieve my goal" I wouldn't be here posting.

[alek76]

Now will start on a small  range. Let's say
    // Configuration for the Puzzle
    // Set minKeyBN and maxKeyBN using the provided base 10 values
    BN_dec2bn(&minKeyBN, "30568377312063203855");
    BN_dec2bn(&maxKeyBN, "30568377312065203855");
    std::string targetAddress = "18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe";


This is how  looks when hits

• Fri Sep 29 18:01:54 2023
• 18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe
• PUZZLE SOLVED: 2023-09-29 18:02:59
• WIF: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZM21gaY8WN2CdwnTG57

You can also stretch the random key space and search for 66 and 67 at once. Something like this:

Code:

Bit 66 CPU Base Key thId 0: 2070B59CFFB6E8A6C
[i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 67 CPU Base Key thId 1: 5F69D80358D3D5461
[0.83 Mkey/s][GPU 0.00 Mkey/s][Total 2^29.06][Prob 0.0%][50% in 3.88754e+34y][Found 0]  [i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 66 CPU Base Key thId 1: 2E3C205D5E1AED2B1
[i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 66 CPU Base Key thId 0: 310A2ED5261C2A060
[0.80 Mkey/s][GPU 0.00 Mkey/s][Total 2^29.18][Prob 0.0%][50% in 4.03042e+34y][Found 0]  [i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 66 CPU Base Key thId 0: 218520C965083E2EC
[i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 67 CPU Base Key thId 1: 5BCD840005DB9C7A0
[0.79 Mkey/s][GPU 0.00 Mkey/s][Total 2^29.29][Prob 0.0%][50% in 4.04933e+34y][Found 0]  [i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 67 CPU Base Key thId 1: 670DE68F544FE981A
[i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 67 CPU Base Key thId 0: 52D16C4062A5F03A4
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^29.35][Prob 0.0%][50% in 3.89443e+34y][Found 0]

[citb0in]

Hey guys, can anyone change the following script to do division either by odd numbers or even numbers?

why not make an effort yourself and beg others all the time? I understand that you can't code, you've already admitted to that and you've been demonstrating it almost daily at regular intervals lately by just posting stupid chatGPT generated code. I would highly recommend you to acquire methodology to create a way for your goal to be achieved. And then start getting involved with Python development and fight your way through the jungle. You won't get far with the Hey Joe mentality. By the way, I would recommend you completely refrain from posting mindless openAI generated code here and pretending you understand any of it. Leave out the code altogether and don't try to make it seem to forum users that you can code. That way you'll be honest, an important step towards achieving your goal. Good luck with your endeavor.

[canable]

Based on the information provided, it appears that the pattern for generating the private key (PVK) values for these Bitcoin addresses involves incrementing the PVK values by a specific sequence of integers. Let's calculate the PVK value for Address 15 and beyond based on the observed pattern:

Address 15: PVK value = Address 14's PVK value + 27
Address 15: PVK value = 10544 + 27
Address 15: PVK value = 10571

So, the PVK value for Address 15 is 10571.

You can continue this pattern to calculate the PVK values for addresses beyond Address 15 by adding the next integer in the sequence to the PVK value of the previous address.

[digaran]

If anyone has any problems with my posts, click that ignore button, I share whatever I can think of, they might be useless, but they could also help others to learn how these things work.  

Please refrain from bringing your personal issues here, we are not responsible for whatever you are going through, honestly with this attitude you don't deserve any sympathy.
Go  unload you garbage on someone else, we haven't seen any positive vibes from the kinds of you, why should we tolerate your negative energy.

[nomachine]

Now will start on a small  range. Let's say
    // Configuration for the Puzzle
    // Set minKeyBN and maxKeyBN using the provided base 10 values
    BN_dec2bn(&minKeyBN, "30568377312063203855");
    BN_dec2bn(&maxKeyBN, "30568377312065203855");
    std::string targetAddress = "18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe";


This is how  looks when hits

• Fri Sep 29 18:01:54 2023
• 18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe
• PUZZLE SOLVED: 2023-09-29 18:02:59
• WIF: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZM21gaY8WN2CdwnTG57

You can also stretch the random key space and search for 66 and 67 at once. Something like this:

Code:

Bit 66 CPU Base Key thId 0: 2070B59CFFB6E8A6C
[i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 67 CPU Base Key thId 1: 5F69D80358D3D5461
[0.83 Mkey/s][GPU 0.00 Mkey/s][Total 2^29.06][Prob 0.0%][50% in 3.88754e+34y][Found 0]  [i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 66 CPU Base Key thId 1: 2E3C205D5E1AED2B1
[i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 66 CPU Base Key thId 0: 310A2ED5261C2A060
[0.80 Mkey/s][GPU 0.00 Mkey/s][Total 2^29.18][Prob 0.0%][50% in 4.03042e+34y][Found 0]  [i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 66 CPU Base Key thId 0: 218520C965083E2EC
[i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 67 CPU Base Key thId 1: 5BCD840005DB9C7A0
[0.79 Mkey/s][GPU 0.00 Mkey/s][Total 2^29.29][Prob 0.0%][50% in 4.04933e+34y][Found 0]  [i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 67 CPU Base Key thId 1: 670DE68F544FE981A
[i] Random Keys - Low Keys Space 2^(67-2) 0x20000000000000000 

Bit 67 CPU Base Key thId 0: 52D16C4062A5F03A4
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^29.35][Prob 0.0%][50% in 3.89443e+34y][Found 0]

There are special requirements here...For example digaran wants to print all addresses from 1 to 10 or any range   How to do that madness here?

Code:

#include "SECP256k1.h"
#include "Int.h"
#include <iostream>
#include <memory>

int main() {
    Int minKey;
    Int maxKey;
    // Configuration
    minKey.SetBase10("1");
    maxKey.SetBase10("10");

    // Initialize SECP256k1
    std::shared_ptr<Secp256K1> secp256k1 = std::make_shared<Secp256K1>();
    secp256k1->Init();

    Int privateKey = minKey;
    Point publicKey;
    std::string caddr;
    std::string wifc;

    while (!privateKey.IsGreater(&maxKey)) {
        publicKey = secp256k1->ComputePublicKey(&privateKey);
        caddr = secp256k1->GetAddress(0, true, publicKey);
        wifc = secp256k1->GetPrivAddress(true, privateKey);
        
        // Display the generated address
        std::string message = caddr +  " ------> " + wifc + "\n";
        std::cout << message;
        std::cout.flush();

        privateKey.AddOne();
    }

    return 0;
}

[alek76]

///

Int PrivateKey = minKey; // THE ERROR
First it is announced, then it is established.
Int PrivateKey;
PrivateKey.Set(&minKey);
Yes, you can do it in different ways....

[digaran]

There are special requirements here...For example digaran wants to print all addresses from 1 to 10 or any range   How to do that madness here?

That request was for the other script which I said it doesn't generate public keys sequentially, a range of 1 to 10 had no pubs for 2, 4, 6 etc, I was interested to  test a few things on my phone, otherwise I have the fastest tools on my laptop.

The lottery script is random, there is 99.999% chance of never landing on a key with random mode, but it was fun to play with, you could for example replace G with your target, also since it generates addresses, it's really slow, you could skip 2 sha256 ( address checksum) and base58 encode if you just generate rmd160.

[nomachine]

Based on the information provided, it appears that the pattern for generating the private key (PVK) values for these Bitcoin addresses involves incrementing the PVK values by a specific sequence of integers. Let's calculate the PVK value for Address 15 and beyond based on the observed pattern:

Address 15: PVK value = Address 14's PVK value + 27
Address 15: PVK value = 10544 + 27
Address 15: PVK value = 10571

So, the PVK value for Address 15 is 10571.

You can continue this pattern to calculate the PVK values for addresses beyond Address 15 by adding the next integer in the sequence to the PVK value of the previous address.

What  is for 66 then ?  

I can even help you further how to program this

import math

# Given list of numbers
numbers = [
    1, 3, 7, 8, 21, 49, 76, 224, 467, 514, 1155, 2683, 5216, 10544, 26867, 51510,
    95823, 198669, 357535, 863317, 1811764, 3007503, 5598802, 14428676, 33185509,
    54538862, 111949941, 227634408, 400708894, 1033162084, 2102388551, 3093472814,
    7137437912, 14133072157, 20112871792, 42387769980, 100251560595, 146971536592,
    323724968937, 1003651412950, 1458252205147, 2895374552463, 7409811047825,
    15404761757071, 19996463086597, 51408670348612, 119666659114170, 191206974700443,
    409118905032525, 611140496167764, 2058769515153876, 4216495639600700,
    6763683971478124, 9974455244496707, 30045390491869460, 44218742292676575,
    138245758910846492, 199976667976342049, 525070384258266191, 1135041350219496382,
    1425787542618654982, 3908372542507822062, 8993229949524469768,
    17799667357578236628, 30568377312064202855
]


Give me math formula that can calculate pattern for WIF 66 here ?
Whoever succeeds in doing this will receive a greater prize than the Nobel Prize.

p.s.
It doesn't even have to be an exact number.
That it is accurate to approximately +/- 8 decimal places.