Bitcoin puzzle transaction ~32 BTC prize to who solves it

[digaran]

144M private keys are a drop in the ocean of keys. What's the point of generating public keys from private keys (it takes a long time). You need to add and multiply and divide public keys (XY coordinates). The process can of course be speeded up if you use C++. Not a single Python script has yet found complex solutions to a puzzle.
You have some unique creative designs from Jean Luc Pons, this is the highest level of programming skill and experience. Everything else can only be modified, new algorithms and new functions can be added to the C++ code. Look in the wrong direction... It's better to find the correct divisor for the unknown private key. Correct - this means the remainder of the division is zero!!! This is a good task, then there will be a result.

144 million keys using python script? Yeah it will take a few hours, at least for me.
I'm not sure about the highest programming skills since kangaroo is outdated, and in practice useless for large keys/ranges.
Also there is a script in python which divides a point by a start/end range, it's really useful to find the divisor, I have both scalar version and point version posted on project development board, there is also a version which operates with 2 targets and divides them by the set range, and on top of that there is a  subtraction function to sub the results of division, I suggest you play around with scalar version and change the range, also change the last digit of your targets  to at least have 10 keys ending with 0 through 9 and then repeat divide ranges with all of them.

Start by subtracting 2^129 from a known k in puzzle 130 range and then use fake #130 as first, and the result of subtraction as second target, start your range from 2, 32 and keep increasing it the next time, 32, 256, then 256, 2048 and so on, try to check the index number, if you see your scalar divided by 48 results in an integer, then that's your  divisor. Set multiples of 48 as start, end range and solve the key.

I'm working on a method to determine with 100% accuracy whether a point divided by a number results in an integer or not. Stay tuned.😉

[1714642218]

1714642218

[1714642218]

1714642218

[1714642218]

1714642218

[1714642218]

1714642218

[mcdouglasx]

144M private keys are a drop in the ocean of keys. What's the point of generating public keys from private keys (it takes a long time). You need to add and multiply and divide public keys (XY coordinates). The process can of course be speeded up if you use C++. Not a single Python script has yet found complex solutions to a puzzle.
You have some unique creative designs from Jean Luc Pons, this is the highest level of programming skill and experience. Everything else can only be modified, new algorithms and new functions can be added to the C++ code. Look in the wrong direction... It's better to find the correct divisor for the unknown private key. Correct - this means the remainder of the division is zero!!! This is a good task, then there will be a result.

144 million keys using python script? Yeah it will take a few hours, at least for me.
I'm not sure about the highest programming skills since kangaroo is outdated, and in practice useless for large keys/ranges.
Also there is a script in python which divides a point by a start/end range, it's really useful to find the divisor, I have both scalar version and point version posted on project development board, there is also a version which operates with 2 targets and divides them by the set range, and on top of that there is a  subtraction function to sub the results of division, I suggest you play around with scalar version and change the range, also change the last digit of your targets  to at least have 10 keys ending with 0 through 9 and then repeat divide ranges with all of them.

Start by subtracting 2^129 from a known k in puzzle 130 range and then use fake #130 as first, and the result of subtraction as second target, start your range from 2, 32 and keep increasing it the next time, 32, 256, then 256, 2048 and so on, try to check the index number, if you see your scalar divided by 48 results in an integer, then that's your  divisor. Set multiples of 48 as start, end range and solve the key.

I'm working on a method to determine with 100% accuracy whether a point divided by a number results in an integer or not. Stay tuned.😉

It is difficult to specify which result is integer or not because they are all within the same curve, and can be represented by several pk.

1/2= 57896044618658097711785492504343953926418782139537452191302581570759080747169
3/2= 57896044618658097711785492504343953926418782139537452191302581570759080747170

[digaran]

It is difficult to specify which result is integer or not because they are all within the same curve, and can be represented by several pk.

1/2= 57896044618658097711785492504343953926418782139537452191302581570759080747169
3/2= 57896044618658097711785492504343953926418782139537452191302581570759080747170

1/2= 0.5
Secp256k1 curve, 1/2=
57896044618658097711785492504343953926418782139537452191302581570759080747169

3/2= 1.5
Secp256k1 curve, 3/2=
57896044618658097711785492504343953926418782139537452191302581570759080747170

When you operate mod n, 1.5 turns into 0.5+1, or half of n +1.  This is true for 1 up to n-1. Like 11/2 is just n/2+5.
So what about 51/2? It's  n/2+25, how about 701/2? It's n/2+350.  How about 1001/2? It's n/2+500.

Now moving forward, 10001/85= 117.65882
1/85= 0.011764706
Subtracting  0.011764706 - 117.65882 = 117.64706, not integer, now we want to know how to find 0.65882 of n, because 1/85 didn't give us 0.65882, it gives us 0.011764706, but  subtracting them gave us some clues, the answer is n.64706th+117.  We don't want our result to be a fraction, so we need to find the remainder of division mod n. 
Now going bigger, 1000001/85= 11764.718, 1000002/85=
 11764.729,   1000003/85= 11764.741,  1000004/85=
 11764.753.

See what happened?
0.011764706 1/85
0.011764718 1million and one/85, I added 0.0 - .
0.011764729 1million and two/85, added 0.0 - .
0.011764741 1m and three/85
0.011764753 1m and four/85
If you remove 0.0 from above fractions, you get the correct answer.

[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.)

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 = 4; // 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;
}

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

Yes...

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

[dextronomous]

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.)

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 = 4; // 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) {
    BIGNUM* randomPrivateKey = generateRandomPrivateKey(minKey, maxKey);

    while (true) {
        // 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();
            }
        }

        // Cleanup 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;
}

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

[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.)

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 = 4; // 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) {
    BIGNUM* randomPrivateKey = generateRandomPrivateKey(minKey, maxKey);

    while (true) {
        // 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();
            }
        }

        // Cleanup 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;
}

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

Use  @alek76 github link....It is exactly the same thing  forked from Jean-Luc PONS. (I removed Printing and command line options from my binaries..)


git clone https://github.com/alek76-2/VanitySearch.git


TO make it work add in Random.cpp

#include <cstring>  (should be changed there in source)

You have in README.md how to compile exe in Windows.

p.s.
this is still in the testing phase

[mcdouglasx]

It is difficult to specify which result is integer or not because they are all within the same curve, and can be represented by several pk.

1/2= 57896044618658097711785492504343953926418782139537452191302581570759080747169
3/2= 57896044618658097711785492504343953926418782139537452191302581570759080747170

1/2= 0.5
Secp256k1 curve, 1/2=
57896044618658097711785492504343953926418782139537452191302581570759080747169

3/2= 1.5
Secp256k1 curve, 3/2=
57896044618658097711785492504343953926418782139537452191302581570759080747170

When you operate mod n, 1.5 turns into 0.5+1, or half of n +1.  This is true for 1 up to n-1. Like 11/2 is just n/2+5.
So what about 51/2? It's  n/2+25, how about 701/2? It's n/2+350.  How about 1001/2? It's n/2+500.

Now moving forward, 10001/85= 117.65882
1/85= 0.011764706
Subtracting  0.011764706 - 117.65882 = 117.64706, not integer, now we want to know how to find 0.65882 of n, because 1/85 didn't give us 0.65882, it gives us 0.011764706, but  subtracting them gave us some clues, the answer is n.64706th+117.  We don't want our result to be a fraction, so we need to find the remainder of division mod n. 
Now going bigger, 1000001/85= 11764.718, 1000002/85=
 11764.729,   1000003/85= 11764.741,  1000004/85=
 11764.753.

See what happened?
0.011764706 1/85
0.011764718 1million and one/85, I added 0.0 - .
0.011764729 1million and two/85, added 0.0 - .
0.011764741 1m and three/85
0.011764753 1m and four/85
If you remove 0.0 from above fractions, you get the correct answer.

51/2 = 25 + 57896044618658097711785492504343953926418782139537452191302581570759080747169

701/2 =350 + 57896044618658097711785492504343953926418782139537452191302581570759080747169

1001/2 =500 + 57896044618658097711785492504343953926418782139537452191302581570759080747169

The results with fractions or float (floating point number) are represented on the curve with integers.

example:

1000001/4 =250000.25

on the curve

86844066927987146567678238756515930889628173209306178286953872356138621370753

publickey

02cdf3e53adf60ad168bccaaed5922ff0a8846de887ca1112bf4a36ae114b32f6b

The longer the fractions, the more difficult it is to calculate their representation in integers on the curve.

It is difficult to know which division is a fraction or not, because the curve sees them as integers.

[albert0bsd]

The results with fractions or float (floating point number) are represented on the curve with integers.

Totally agree with you and not only that.

• All negative numbers (Result of some subtractions) are still represented by positive values.
• All numbers can be fractions or integers. x/(N-1) where N is the Order of the curve
• Negative odd values are posive even values.

And the other way around is also valid, The lats point is also some important because we can't know if a subtraction result is negative or posive, odd or even.

IMO After 3 years of learning all that I can, I reached the conclusion that there is not an Arithmetic operation with the public key  that can lead in any bit disclosure.

is this puzzle still unsolved to date?

Not all, just some of them, the challenge still have 956.5 BTC

[digaran]

It is difficult to know which division is a fraction or not, because the curve sees them as integers.

Of course it's difficult, that's one reason to love bitcoin and be assured of it's security, I don't deny that. My goal is to find out what is the remainder of a fraction for different values and if there is a way to find that out, like 4501/230 =
 19.56956522, and I want to know how to detect .56956522 and extract it's representation on the curve, we have 4500/230 =  19.56521739, I want to know how we could find curve representations of :
.56956522  and
.56521739 difference between them is : .434783
Now if we could find .434783 on the curve we can potentially determine the range to solve 4501.

[_Counselor]

It is difficult to know which division is a fraction or not, because the curve sees them as integers.

Of course it's difficult, that's one reason to love bitcoin and be assured of it's security, I don't deny that. My goal is to find out what is the remainder of a fraction for different values and if there is a way to find that out, like 4501/230 =
 19.56956522, and I want to know how to detect .56956522 and extract it's representation on the curve, we have 4500/230 =  19.56521739, I want to know how we could find curve representations of :
.56956522  and
.56521739 difference between them is : .434783
Now if we could find .434783 on the curve we can potentially determine the range to solve 4501.

Everything is much simpler than it seems if you forget about decimal fractions and work with it as with simple fractions.

4501/230 = 19 ¹³¹/₂₃₀ Fraction part = 131/230 or 131*modinv(230) on curve

4500/230 = 19 ¹³⁰/₂₃₀ = 19 ¹³/₂₃

⁴⁵⁰¹/₂₃₀ - ⁴⁵⁰⁰/₂₃₀ = ¹/₂₃₀ => difference on curve = 1*modinv(230)

If you really need to find decimal fraction, just convert it to simple fraction:
0.5 = 5/10 = 1/2 = 1 * modinv(2) (or 5*modinv(10) - doesn't matter).
0.434783 = 434783/1000000 = 434783*modinv(1000000)

[mcdouglasx]

It is difficult to know which division is a fraction or not, because the curve sees them as integers.

Of course it's difficult, that's one reason to love bitcoin and be assured of it's security, I don't deny that. My goal is to find out what is the remainder of a fraction for different values and if there is a way to find that out, like 4501/230 =
 19.56956522, and I want to know how to detect .56956522 and extract it's representation on the curve, we have 4500/230 =  19.56521739, I want to know how we could find curve representations of :
.56956522  and
.56521739 difference between them is : .434783
Now if we could find .434783 on the curve we can potentially determine the range to solve 4501.

The representation in the curve in decimals is obtained by dividing N:

N = 115792089237316195423570985008687907852837564279074904382605163141518161494337

1/2= 0.5

N/2= 0.5

1/4= 0.25

N/4= -0.25

then its sequence is

(N/2)+1= 1.5
(N/2)+2= 2.5
(N/2)+1000= 1000.5

Any division of N that is less than N/2 will show its result as negative in ECC.

N/4= -0.25

you transfer it to positive like this:

N-(N/4)

additional info.

if you want to find any pubkey reflection

NM1= 115792089237316195423570985008687907852837564279074904382605163141518161494336
NM1_pub= 0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 (or -1)

pk= 5

pub-key= 022f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4

N-pk    (if you use numbers)

N-pk= 115792089237316195423570985008687907852837564279074904382605163141518161494332
N-pk pub=032f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4

or

(NM1_pub - pub-key) + 1   #(ECC)

[digaran]

I already know these things, I should provide real examples,
What I have been working on is this :
 34771879058060 /897125896 = 38759.1966892236
Of course the integer above is supposedly unknown, but dividing it would make it small, now if I know with which value should I divide n to reach that bolded part, then we could just brute force "38759" keys as the representation of bolded part on curve to be our start range, then brute forcing 38759 keys should 100% give us our target, also note that our k in this example is unknown, so you can't calculate anything based on your knowledge about the key.

[Woz2000]

@albert0bsd

Trying to understand...

Why would endomorphism not work with BSGS if I am searching the entire space?

[alek76]

Use  @alek76 github link....It is exactly the same thing  forked from Jean-Luc PONS. (I removed Printing and command line options from my binaries..)


git clone https://github.com/alek76-2/VanitySearch.git


TO make it work add in Random.cpp

#include <cstring>  (should be changed there in source)

You have in README.md how to compile exe in Windows.

p.s.
this is still in the testing phase

It's not the same! You should look carefully at the GPUEngine.cu code. Which functions were prohibited for use, and which were fixed and allowed, and why this was done.
The Y coordinate is calculated, so only the __device__ void ComputeKeys() function is used, and this is due to the prohibition of reuse of _GetHash160Comp() - to increase speed. It is better to calculate the Y coordinate once than to calculate hash160 twice (in which there are 2 functions sha256 + 1 time Ripemd160).
So what will be faster???
You need to look at someone else’s code carefully before drawing such conclusions. Is this the same thing or not?


Binary build using CUDA 10.2 Available for downloads https://github.com/alek76-2/VanitySearch/tree/main/bin

NO testing phase  

Well, if you ask why I removed the endomorphism? It is only effective for 256-bit keys, because... k1 and k2 are half the length of 256 bits (this is how they get the speedup). In this case, it is useless for solving the 32 BTC Puzzle.
With endomorphism you will search in space for 128 bits for heating an apartment with a video card  

[nomachine]

Use  @alek76 github link....It is exactly the same thing  forked from Jean-Luc PONS. (I removed Printing and command line options from my binaries..)


git clone https://github.com/alek76-2/VanitySearch.git


TO make it work add in Random.cpp

#include <cstring>  (should be changed there in source)

You have in README.md how to compile exe in Windows.

p.s.
this is still in the testing phase

It's not the same! You should look carefully at the GPUEngine.cu code. Which functions were prohibited for use, and which were fixed and allowed, and why this was done.
The Y coordinate is calculated, so only the __device__ void ComputeKeys() function is used, and this is due to the prohibition of reuse of _GetHash160Comp() - to increase speed. It is better to calculate the Y coordinate once than to calculate hash160 twice (in which there are 2 functions sha256 + 1 time Ripemd160).
So what will be faster???
You need to look at someone else’s code carefully before drawing such conclusions. Is this the same thing or not?


Binary build using CUDA 10.2 Available for downloads https://github.com/alek76-2/VanitySearch/tree/main/bin

NO testing phase  

Well, if you ask why I removed the endomorphism? It is only effective for 256-bit keys, because... k1 and k2 are half the length of 256 bits (this is how they get the speedup). In this case, it is useless for solving the 32 BTC Puzzle.
With endomorphism you will search in space for 128 bits for heating an apartment with a video card  

Sorry, but I really didn't look.I don't have a GPU here (ADLINK Ampere Altra 128-core ) so I don't even care about that part (removed all CUDA code in my version). I'm only interested in the CPU how to speed up in a specific environment targeting platform specific compiler ...I have to admit that Open SSL is very good.  

[alek76]

I have to admit that Open SSL is very good.  

To have a good probability of finding, you need a good randomness of the search. Sounds logical  . I have not studied probability theory. Previously, the program included the Mersenne Twister algorithm. The Mersenne Twister is a general-purpose pseudorandom number generator (PRNG) developed in 1997 by Makoto Matsumoto.
This algorithm is predictable, and external events are seconds of time and a hashed SEED from the command line.
OpenSSL is certainly better.

[zahid888]

puzzle: 30 frontHex: 3d94cd64 Binary: 111101100101001100110101100100        Zeros: 14        Ones: 16

puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13

puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14

puzzle: 42 frontHex: 2a221c58 Binary: 101010001000100001110001011000        Zeros: 19        Ones: 11

puzzle: 46 frontHex: 2ec18388 Binary: 101110110000011000001110001000        Zeros: 18        Ones: 12

puzzle: 50 frontHex: 22bd43c2 Binary: 100010101111010100001111000010        Zeros: 16        Ones: 14

puzzle: 54 frontHex: 236fb6d5 Binary: 100011011011111011011011010101        Zeros: 11        Ones: 19

puzzle: 58 frontHex: 2c675b85 Binary: 101100011001110101101110000101        Zeros: 14        Ones: 16

puzzle: 62 frontHex: 363d541e Binary: 110110001111010101010000011110        Zeros: 14        Ones: 16

frontHex: 3aea4435     Zeros: 15 Ones: 15     Bin: 111010111010100100010000110101     Addr: 13zb1hQbWVLbiRYaoLhWuCDY7WcAw4dXF9
frontHex: 354d62e5     Zeros: 14 Ones: 16     Bin: 110101010011010110001011100101     Addr: 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr
frontHex: 345ccb1b     Zeros: 14 Ones: 16     Bin: 110100010111001100101100011011     Addr: 13zb1hQbWVi8cYnLyEus3LFucU535Bm52s
frontHex: 33dfe480     Zeros: 14 Ones: 16     Bin: 110011110111111110010010000000     Addr: 13zb1hQbWVBmBqFsBnFR49ZxK8A6RXeaMg
frontHex: 35e3dacf     Zeros: 10 Ones: 20     Bin: 110101111000111101101011001111     Addr: 13zb1hQbWVByHkiAWQr5wmdiSyeAzNBwEb     

 Bin: 11 1 0 1 0 1 1 1 0 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 1 0 1 0 1 
 Bin: 11 0 1 0 1 0 1 0 0 1 1 0 1 0 1 1 0 0 0 1 0 1 1 1 0 0 1 0 1 
 Bin: 11 0 1 0 0 0 1 0 1 1 1 0 0 1 1 0 0 1 0 1 1 0 0 0 1 1 0 1 1 
 Bin: 11 0 0 1 1 1 1 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 0 0 0 0 0 
 Bin: 11 0 1 0 1 1 1 1 0 0 0 1 1 1 1 0 1 1 0 1 0 1 1 0 0 1 1 1 1 
 Bin: 11 X X X X X 1 X X X X X X X 1 X X X X X X X X X X X X X X

URange : 37cac165000000000:37cac165fffffffff
FntHex : 37cac165x
Binary : 110111110010101100000101100101 num_zeros : 14, num_ones : 16
Cnditn : 11xxxxx1xxxxxxx1xxxxxxxxxxxxxx

VanBitCrackenS v1.0
Keyspace start=37CAC165000000000
Keyspace   end=37CAC165FFFFFFFFF
Search: 15 prefixes (Lookup size 15) [Compressed]
Started at Tue Sep 26 18:06:24 2023
CPU threads used: 0
GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
1108.527 MK/s (GPU 1108.527 MK/s) (2^36.14) [00:01:07 Elapsed Time][0]
[EXIT] Reached end of keyspace.

Finish at Tue Sep 26 18:07:32 2023

Lastt Found Address : 13zb1hQbQVEsGkStRa5QNndvakyhr9ji6M  36DB505C509D330C1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^ ^
Charr Match Totalss : 9
Total Found Address : 458
Total scned rangess : 58410

URange : 3967c187000000000:3967c187fffffffff
FntHex : 3967c187x
Binary : 111001011001111100000110000111 num_zeros : 14, num_ones : 16
Cnditn : 11xxxxx1xxxxxxx1xxxxxxxxxxxxxx

VanBitCrackenS v1.0
Keyspace start=3967C187000000000
Keyspace   end=3967C187FFFFFFFFF
Search: 15 prefixes (Lookup size 15) [Compressed]
Started at Tue Sep 26 18:07:38 2023
CPU threads used: 0
GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
1118.864 MK/s (GPU 1118.864 MK/s) (2^36.25) [00:01:13 Elapsed Time][1]
[EXIT] Reached end of keyspace.

Finish at Tue Sep 26 18:08:52 2023

Lastt Found Address : 13zb1hQbBpwfx2dfsz96hZc3eyBAskknZD  3967C187FFBA0F1D1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 459
Total scned rangess : 58411

URange : 32f0e8ce000000000:32f0e8cefffffffff
FntHex : 32f0e8cex
Binary : 110010111100001110100011001110 num_zeros : 14, num_ones : 16
Cnditn : 11xxxxx1xxxxxxx1xxxxxxxxxxxxxx

VanBitCrackenS v1.0
Keyspace start=32F0E8CE000000000
Keyspace   end=32F0E8CEFFFFFFFFF
Search: 15 prefixes (Lookup size 15) [Compressed]
Started at Tue Sep 26 18:08:57 2023
CPU threads used: 0
GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
1119.154 MK/s (GPU 1119.154 MK/s) (2^36.25) [00:01:13 Elapsed Time][0]
[EXIT] Reached end of keyspace.

Finish at Tue Sep 26 18:10:12 2023

Lastt Found Address : 13zb1hQbBpwfx2dfsz96hZc3eyBAskknZD  3967C187FFBA0F1D1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 459
Total scned rangess : 58412

When applying these conditions, I reduce the ranges too much. Should I have to create a pool with such stupidity?

Something interesting I found.. 

1FeexV6bAHo9rxCoRCbMbdGsVA13ca3Cc6  2B91CA5E6DE963B9F
1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF

[albert0bsd]

your first analisys seems interesting but i think that those repeated bits in some specific puzzles are just a coincide.

Lastt Found Address : 13zb1hQbQVEsGkStRa5QNndvakyhr9ji6M  36DB505C509D330C1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^ ^
Charr Match Totalss : 9
Total Found Address : 458
Total scned rangess : 58410

Charr Match Totalss : 9 ??

Only the first 7 match, with out counting the first 1, i mean it is impossible  that the first character is not 1 for legacy address P2PKH

Lastt Found Address : 13zb1hQbBpwfx2dfsz96hZc3eyBAskknZD  3967C187FFBA0F1D1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 459
Total scned rangess : 58411

Again only 7 match

Lastt Found Address : 13zb1hQbBpwfx2dfsz96hZc3eyBAskknZD  3967C187FFBA0F1D1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 459
Total scned rangess : 58412

Only 7, the thing is that all the characters need to match

1FeexV6bAHo9rxCoRCbMbdGsVA13ca3Cc6  2B91CA5E6DE963B9F
1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF

Those M aren't even in the same position, those extra characters doesn't metter, it need to match all 160 bits..

Should I have to create a pool with such stupidity?

No

[zahid888]

Should I have to create a pool with such stupidity?

No

Thank you for your suggestions. You are highly experienced, if you have ever used a method in your experience (without revealing the public key) that even slightly brings us closer to our goal, please do share it.

Edit-----------

Or any method to reach closer to pubkey

039f7bed2fb18144484a1db48d50c01e9ed80dd7a4166d7c1d2b7ca73c19d97c74  20d45a6a76753cb0a8fedc855ed3cee4705a1a3e
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^ ^^  ^           ^   ^  ^


020b03dcc67a5279a4508319a498f529853de9c635343e6e7384e55244f73fbd12  20d45a6a764133470ef8e736e371fa347572bc35
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^  ^   ^   ^          ^    ^  ^


0276fa074b58763dfba10124f49ee0a0e09856741a288bf9a45e6fdabc7479cd84  20d45a6a767f3f18ec9bced9cce1709114540295
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^  ^    ^        ^   ^   ^    ^


033fe62b18c8bae2df06223b4e10cb75237a3a33650c496db4ed6d5968e7a0c8b1  20d45a6a7625d3b68c702a8b993379f0100758c9
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^^^     ^         ^ ^       ^


033fe62b18c8bae2df06223b4e10cb75237a3a33650c496db4ed6d5968e7a0c8b1  20d45a6a7625d3b68c702a8b993379f0100758c9
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^^^     ^         ^ ^       ^

[digaran]

I can't understand your method, why are you looking for base58 addresses, can you at least explain this non existing mathematical relation? Base58 addresses distribution  can not be determined by permutation equation.
You know what you should do? You have to explain a mathematical logic behind your method which should be reproducible and   verifiable by everyone else.
Nobody knows, maybe hash 0 famous address with all 0 characters is somewhere in 66 or 67 bit range, right?  When there is no possible way  to accurately determine that, why do you keep doing it over and over and expect a different result?