Bitcoin puzzle transaction ~32 BTC prize to who solves it

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

[bestie1549]

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.

you must be a very big joker if you think there is a pattern in the numbers you see up there, the only pattern you can ever find is the puzzle numbers 1 to 65, anything apart from that then you must be joking. if you like turn it to ASCII or WIF or HEX or DEC or Base 9 or Base 2 or any format you want. a Random number will forever remain a random number

the only problem we are having here is the fact that we cannot generate a defined public key range (e.g 66 bit range public keys) without having to involve the private key. what would be the usage of the curve if we could do that then?

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

you must be a very big joker if you think there is a pattern in the numbers you see up there

Tell  that to him. 

[unclevito]

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.

you must be a very big joker if you think there is a pattern in the numbers you see up there

Tell  that to him.  

somewhat of a visual pattern, but reminds me of random noise in a AM radio IF too.
[1.0986122886681098, 0.8472978603872034, 0.13353139262452252, 0.9650808960435873, 0.8472978603872034, 0.4389130421757046, 1.0809127115687085, 0.7346832058138579, 0.095894007786268, 0.8096323575007283, 0.8428352274697302, 0.6647952531808645, 0.7038261531358003, 0.9353417899552472, 0.6508771958620958, 0.6207267760911943, 0.7291373836260231, 0.5875931361451538, 0.8815486874877241, 0.7412742883673946, 0.5068092100595862, 0.621442479911261, 0.9466649690007394, 0.8328956894510604, 0.4968002070443873, 0.7191383042437529, 0.7096890523067678, 0.565494345222092, 0.9471441493574098, 0.7104500196844334, 0.3862202442339999, 0.8360595282539585, 0.6831637178413494, 0.3528424038245319, 0.7454998789960143, 0.8608227563358781, 0.38255630630651183, 0.7896553545955527, 1.1315057477074362, 0.37359383611238073, 0.6858758829076486, 0.9396904576187914, 0.7318717272660606, 0.26087874561462243, 0.9442514298159388, 0.8449031946466405, 0.46864644180339354, 0.7606493566316814, 0.4013210422240192, 1.2145368832080123, 0.7168958843120095, 0.47256334190535654, 0.38845964139438394, 1.1026819053976311, 0.38643947837596926, 1.1398842299982945, 0.3691677366484285, 0.9653316192351014, 0.7708920423038066, 0.22805524036508018, 1.0083967352657979, 0.8333510086282203, 0.682707702906626, 0.540786284089215]

[Baskentliia]

Hi all,

to what extent can the performance and the hit probability of these two tools be compared and what significance do they then have?

For example:

- we run Kangaroo in multi-GPU mode on several modern GPUs and achieve a displayed speed of 15 GKey/s

- we run keyhunt in BSGS mode on 8 CPU threads with about 16GB RAM allocation and get about 80 PKey/s.

Is Kangaroo with multi-GPU usage more advantageous and more likely to get a hit, even though keyhunt with CPU usage in BSGS can process 80 PKey/s?

From this numerical example, one would think that keyhunt with the 80 PKey/s would have to be worlds better. But is that the case or is it not possible to compare this at all and the given speed rates are completely useless for the comparison?

[citb0in]

From this numerical example, one would think that keyhunt with the 80 PKey/s would have to be worlds better. But is that the case ... ?

No.

... or is it not possible to compare this at all and the given speed rates are completely useless for the comparison?

Correct.

You cannot compare the performance rate displayed by those two programs as they heavily differ.

[mcdouglasx]

Hi all,

to what extent can the performance and the hit probability of these two tools be compared and what significance do they then have?

For example:

- we run Kangaroo in multi-GPU mode on several modern GPUs and achieve a displayed speed of 15 GKey/s

- we run keyhunt in BSGS mode on 8 CPU threads with about 16GB RAM allocation and get about 80 PKey/s.

Is Kangaroo with multi-GPU usage more advantageous and more likely to get a hit, even though keyhunt with CPU usage in BSGS can process 80 PKey/s?

From this numerical example, one would think that keyhunt with the 80 PKey/s would have to be worlds better. But is that the case or is it not possible to compare this at all and the given speed rates are completely useless for the comparison?

through the scientific method.
Test different keys in different ranges, x number of times, and you will know which method finds those keys faster and under what circumstances.

[bestie1549]

Hi all,

to what extent can the performance and the hit probability of these two tools be compared and what significance do they then have?

For example:

- we run Kangaroo in multi-GPU mode on several modern GPUs and achieve a displayed speed of 15 GKey/s

- we run keyhunt in BSGS mode on 8 CPU threads with about 16GB RAM allocation and get about 80 PKey/s.

Is Kangaroo with multi-GPU usage more advantageous and more likely to get a hit, even though keyhunt with CPU usage in BSGS can process 80 PKey/s?

From this numerical example, one would think that keyhunt with the 80 PKey/s would have to be worlds better. But is that the case or is it not possible to compare this at all and the given speed rates are completely useless for the comparison?

the easiest example I can give to you for this question is a "web" and a "gunshot"
now picture both having the same momentum
Kangaroo would be considered a "web" moving at the same momentum as the "gunshot" from BSGS
and what do webs do? it spreads, covering so much area and what do gunshots do? it moves on a straight line
Now the preference is you choice and your available resources
they're both super fast like I've explained earlier.
let's say you have a single 4090 and 16 cpu threads and you combined both and you got the speed of 5GKey/s
and you choose not to use the 4090 but you rather use the 16 cpu thread on your machine and you have 128GB RAM and you chose -k 7000 and you achieved the speed of 1 EKey/s you got so much momentum on both processes but based on my calculations, you would be 90% slower using the latter compared to the former because they are both having ETAs which can easily be calculated
Mind you this has nothing to do with what I am saying, it has everything to do with your preference and resources

[BarryWood]

Hey all, correct me if I'm wrong please: Since the rewards got multiplied by 10X nothing has been found! Correct?

[mcdouglasx]

Hey all, correct me if I'm wrong please: Since the rewards got multiplied by 10X nothing has been found! Correct?

only #125

[nomachine]

- we run keyhunt in BSGS mode on 8 CPU threads with about 16GB RAM allocation and get about 80 PKey/s.

Is Kangaroo with multi-GPU usage more advantageous and more likely to get a hit, even though keyhunt with CPU usage in BSGS can process 80 PKey/s?

Try changing the random generator in both. Play what works best in your environment.
example

keyhunt.cpp

replace

Code:

#include <sys/random.h>

to

Code:

#include <random>

replace  seed random generator with minstd_rand rng

Code:

#if defined(_WIN64) && !defined(__CYGWIN__)
    // Any Windows secure random source goes here
    rseed(clock() + time(NULL) + rand());
#else
    std::random_device rd;
    std::minstd_rand rng(rd());
    
    // Seed the random number generator
    rseed(rng());
#endif

I have from 80  to ~177 Pkeys/s (177940438134284990 keys/s)
These apps can't get better if we don't all work on them and test them.