Bitcoin puzzle transaction ~32 BTC prize to who solves it

[citb0in]

Check for yourself, generate a random key and tell us how many 1s and 0s it has. Do this at least 10 times and let us know.

you have not (yet) understood

Please, explain to me.

Code:

#!/bin/usr/env python3
#by citb0in, 2023/Aug/11
import random

def count_zeros_ones(binary_str):
    count_zeros = binary_str.count('0')
    count_ones = len(binary_str) - count_zeros
    return count_zeros, count_ones

def main():
    while True:
        n_input = input("Enter the number of random numbers to generate (or 'inf' for infinite): ")

        if n_input.lower() == 'inf':
            n = None
        else:
            n = int(n_input)

        bit_range = 2**66 - 1

        print(f"Generating {n if n is not None else 'infinite'} random numbers in a 66-bit range:")

        while n is None or n > 0:
            if n is not None:
                n -= 1

            num = random.randint(0, bit_range)
            binary_str = format(num, '066b')
            count_zeros, count_ones = count_zeros_ones(binary_str)

            print(f"Decimal: {num}")
            print(f"Hex: {hex(num)}")
            print(f"Binary: {binary_str}")
            print(f"Number of Zeros: {count_zeros}")
            print(f"Number of Ones: {count_ones}")
            print(f"Percentage of Zeros: {count_zeros / 66 * 100:.2f}%")
            print(f"Percentage of Ones: {count_ones / 66 * 100:.2f}%")
            print("=" * 30)

            zero_percentage = count_zeros / 66 * 100
            one_percentage = count_ones / 66 * 100

            if zero_percentage > 70 or one_percentage > 70:
                print("Binary percentage condition met. Exiting.")
                print(f"Found number: {num}")
                return

if __name__ == "__main__":
    main()

in this example I have entered 70% for imbalance of zero's and one's. Run the python program and enter 'inf' at the prompt and after a few seconds you will get a hit.

Decimal: 52671848116805094393
Hex: 0x2daf7fecb797ecbf9
Binary: 101101101011110111111111101100101101111001011111101100101111111001
Number of Zeros: 19
Number of Ones: 47
Percentage of Zeros: 28.79%
Percentage of Ones: 71.21%

EDIT: here's another example using a spread of > 80% imbalance in less than 5 seconds after program start

Generating infinite random numbers in a 66-bit range:
Binary percentage condition met. Exiting.
Found number: 27742332034348056594
Hex: 0x18100900004418012
Binary: 011000000100000000100100000000000000000100010000011000000000010010
Number of Zeros: 55
Number of Ones: 11
Percentage of Zeros: 83.33%
Percentage of Ones: 16.67%

and some additional ones even greater than > 85%

Decimal: 288239249823367425
Hex: 0x4000812100c0101
Binary: 000000010000000000000010000001001000010000000011000000000100000001
Number of Zeros: 57
Number of Ones: 9
Percentage of Zeros: 86.36%
Percentage of Ones: 13.64%
==============================
Decimal: 54056408995333132
Hex: 0xc00c048000040c
Binary: 000000000011000000000011000000010010000000000000000000010000001100
Number of Zeros: 57
Number of Ones: 9
Percentage of Zeros: 86.36%
Percentage of Ones: 13.64%
==============================

I also suggest to use "secrets" libary instead of "random" to generate true random numbers. The last two shown examples (>85% imbalance) shown here were using python's "secrets" library.
Is this enough to understand the meaning of randomness ?

[1714860662]

1714860662

[1714860662]

1714860662

[1714860662]

1714860662

[bestie1549]

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

[james5000]

Check for yourself, generate a random key and tell us how many 1s and 0s it has. Do this at least 10 times and let us know.

you have not (yet) understood

Please, explain to me.

Code:

#!/bin/usr/env python3
#by citb0in, 2023/Aug/11
import random

def count_zeros_ones(binary_str):
    count_zeros = binary_str.count('0')
    count_ones = len(binary_str) - count_zeros
    return count_zeros, count_ones

def main():
    while True:
        n_input = input("Enter the number of random numbers to generate (or 'inf' for infinite): ")

        if n_input.lower() == 'inf':
            n = None
        else:
            n = int(n_input)

        bit_range = 2**66 - 1

        print(f"Generating {n if n is not None else 'infinite'} random numbers in a 66-bit range:")

        while n is None or n > 0:
            if n is not None:
                n -= 1

            num = random.randint(0, bit_range)
            binary_str = format(num, '066b')
            count_zeros, count_ones = count_zeros_ones(binary_str)

            print(f"Decimal: {num}")
            print(f"Hex: {hex(num)}")
            print(f"Binary: {binary_str}")
            print(f"Number of Zeros: {count_zeros}")
            print(f"Number of Ones: {count_ones}")
            print(f"Percentage of Zeros: {count_zeros / 66 * 100:.2f}%")
            print(f"Percentage of Ones: {count_ones / 66 * 100:.2f}%")
            print("=" * 30)

            zero_percentage = count_zeros / 66 * 100
            one_percentage = count_ones / 66 * 100

            if zero_percentage > 70 or one_percentage > 70:
                print("Binary percentage condition met. Exiting.")
                print(f"Found number: {num}")
                return

if __name__ == "__main__":
    main()

in this example I have entered 70% for imbalance of zero's and one's. Run the python program and enter 'inf' at the prompt and after a few seconds you will get a hit.

Decimal: 52671848116805094393
Hex: 0x2daf7fecb797ecbf9
Binary: 101101101011110111111111101100101101111001011111101100101111111001
Number of Zeros: 19
Number of Ones: 47
Percentage of Zeros: 28.79%
Percentage of Ones: 71.21%

Is this enough to understand the meaning of randomness ?

Generate randomly without defining percentages.

[citb0in]

Generate randomly without defining percentages.

Did you read the code?

Code:

...
bit_range = 2**66 - 1
...
num = random.randint(0, bit_range)

[tptkimikaze]

I'm reading the post and feel so funny about it.

I have no idea what's the point to argue about. One believe in power of random but another is discussing about math probability. You can even get 90% of 0 or 1 sometime but it's rare. James idea is just a type of probability to eliminate the less likely combination and doesn't guarantee it will find the key, as simple as that. Why is that so difficult to understand and try to bash people logical idea when they themselves can't find any. Is that so difficult to open the mind and listen to others?

[james5000]

Exactly, it's just a logic to avoid brute force on all combinations. If it doesn't make sense, present your idea.

[tptkimikaze]

Puzzle: 30       Zeros: 14       Ones: 16        Percent 0: 46.67%       Percent 1: 53.33%       Decimal: 1033162084 | Binary: 111101100101001100110101100100
Puzzle: 60       Zeros: 28       Ones: 32        Percent 0: 46.67%       Percent 1: 53.33%       Decimal: 1135041350219496382 | Binary: 111111000000011110100001100000100101001101100111101110111110

Puzzle: 32       Zeros: 17       Ones: 15        Percent 0: 53.12%       Percent 1: 46.88%       Decimal: 3093472814 | Binary: 10111000011000101010011000101110
Puzzle: 64       Zeros: 34       Ones: 30        Percent 0: 53.12%       Percent 1: 46.88%       Decimal: 17799667357578236628 | Binary: 1111011100000101000111110010011110110000100100010001001011010100

Puzzle: 33       Zeros: 17       Ones: 16        Percent 0: 51.52%       Percent 1: 48.48%       Decimal: 7137437912 | Binary: 110101001011011001010100011011000
Puzzle: 66       Zeros: 34       Ones: 32        Percent 0: 51.52%       Percent 1: 48.48%       Decimal: ? ? ? ? ? ? ? | Binary: ? ? ? ? ? ? ?
       ☝☝             ☝☝           ☝☝                  ☝☝☝☝                  ☝☝☝☝       Little Prediction according to previous binaries 

Do you see any 80% or even 70% here? If he didn't see it, why is he so convince that James idea doesn't work? If you eliminate the less likely 80% above and 20% below, it is still kind of logical idea to eliminate those less likely key. Is that so difficult to understand? Nobody denying the key might be at above 80 or below 20, it's just less likely. That's what we call "Probability" in maths, not cluelessly brute forcing 100% of the range.

[tptkimikaze]

Exactly, it's just a logic to avoid brute force on all combinations. If it doesn't make sense, present your idea.

In my honest opinion, your idea is definitely have logic. Even if you can't find 66, you still have 67, 68, 69 unless all random hidden at top 70 or below 30.

[bestie1549]

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software

[lordfrs]

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software

where did you rent the cards ?

[bestie1549]

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software

where did you rent the cards ?

vast.ai

[bestie1549]

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software

where did you rent the cards ?

vast.ai

I achieved the same result with 12 devices in a single machine

"
KeyHunt-Cuda v1.07

COMP MODE    : COMPRESSED
COIN TYPE    : BITCOIN
SEARCH MODE  : Single Address
DEVICE       : GPU
CPU THREAD   : 0
GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
GPU GRIDSIZE : 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 10:07:11 2023
Global start : 2E601111111111111 (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 119FEEEEEEEEEEEEF (65 bit)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

[00:04:38] [CPU+GPU: 71921.28 Mk/s] [GPU: 71921.28 Mk/s] [C: 0.000094 %] [R: 0] [T: 19,155,554,140,160 (45 bit)] [F: 0]
"

But the time is still not adding up... if you can do the calculations and also note the costs of renting the machines. you would end up resorting to random generation of at least the 1st 1 to 3 characters because scanning all that range from 20 to wherever you think the key would be doesn't cost pennies

but the 1s and 0s scanning can assure you you scanned all the ranges covering that specifically defined bit ranges without worries
and you can just keep doing it over and over again until you find the bit configuration for the specified puzzle you're searching for

[tptkimikaze]

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software

where did you rent the cards ?

vast.ai

I achieved the same result with 12 devices in a single machine

"
KeyHunt-Cuda v1.07

COMP MODE    : COMPRESSED
COIN TYPE    : BITCOIN
SEARCH MODE  : Single Address
DEVICE       : GPU
CPU THREAD   : 0
GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
GPU GRIDSIZE : 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 10:07:11 2023
Global start : 2E601111111111111 (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 119FEEEEEEEEEEEEF (65 bit)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

[00:04:38] [CPU+GPU: 71921.28 Mk/s] [GPU: 71921.28 Mk/s] [C: 0.000094 %] [R: 0] [T: 19,155,554,140,160 (45 bit)] [F: 0]
"

But the time is still not adding up... if you can do the calculations and also note the costs of renting the machines. you would end up resorting to random generation of at least the 1st 1 to 3 characters because scanning all that range from 20 to wherever you think the key would be doesn't cost pennies

but the 1s and 0s scanning can assure you you scanned all the ranges covering that specifically defined bit ranges without worries
and you can just keep doing it over and over again until you find the bit configuration for the specified puzzle you're searching for

I guess that's what James idea trying to tell. Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.

[tptkimikaze]

Code:

from itertools import combinations
import sys


def place_ones(size, count):
    for positions in combinations(range(size), count):
        p = [0] * size

        for i in positions:
            p[i] = 1

        yield p

f = open("demo.txt", "a")
print(list(place_ones(60, 30)), file=f)

f.close())

Simple combination for bits. Maybe someone can add some coding to convert 0s and 1s to hexadecimal, print in bat file, put it in bitcrack and run it.

Step 1

Let's say start scanning from 60 bits.

0s - 30 - 1s -30 = 50%
0s - 31 - 1s  29 = 51.67%
0s - 32 - 1s  28 = 53.4%
0s - 33 - 1s  27 = 55%
0s - 34 - 1s  26 = 56.67%
0s - 35 - 1s  25 = 58.34%
0s - 36 - 1s  24 = 60%

Then reverse 0s and 1s position in max 60% which is most likely where the key are.

Step 2
Convert Binary to Hexa

Step 3
Print in .CMD for continuous execution in Bitcrack.

Step 4
Run until it hits the key or else increase the percentages if it doesn't.

Make sense or any argument?

I am doing it already but doesn't have huge power like you guys. Maybe share it here and someone can crack it very soon here.

[vneos]

Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.

The key is how to write code to run the specified 0 and 1 digits on the gpu.

Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences.

If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced.

[tptkimikaze]

Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.

The key is how to write code to run the specified 0 and 1 digits on the gpu.

Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences.

If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced.

You don't write it in GPU. Just write it in Python, print it in CMD and automate it in Bitcrack. Then the whole thing transfered to GPU already with Bitcrack.

[tptkimikaze]

Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.

The key is how to write code to run the specified 0 and 1 digits on the gpu.

Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences.

If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced.

Step 1

Let's say start scanning from 60 bits. Coding in Python.

0s - 30 - 1s -30 = 50%
0s - 31 - 1s  29 = 51.67%
0s - 32 - 1s  28 = 53.4%
0s - 33 - 1s  27 = 55%
0s - 34 - 1s  26 = 56.67%
0s - 35 - 1s  25 = 58.34%
0s - 36 - 1s  24 = 60%

Then reverse 0s and 1s position in max 60% which is most likely where the key are.

Step 2
Convert Binary to Hexa

Step 3
Print in .CMD for continuous execution in Bitcrack.

Step 4
Run until it hits the key or else increase the percentages if it doesn't.

Make sense?

[vneos]

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Code:

000000000000000000000000000000000000000000000000000000003d94cd64
hash160: d39c4704664e1deb76c9331e637564c257d68a08
Target hash found!
Time: 0 h, 1 m, 28 s

Code:

import hashlib
import ecdsa
import random
import time
from multiprocessing import Process, Event

target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"

def binary_to_hex(bin_string):
    return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)


def worker(num_zeros, num_ones, stop_event):


    while True:
        if stop_event.is_set():
            break

        bits = ['0'] * num_zeros + ['1'] * (num_ones - 4)
        random.shuffle(bits)

        bits.insert(0, '1')
        bits.insert(1, '1')
        bits.insert(2, '1')
        bits.insert(3, '1')
        private_key_bin = ''.join(bits)

        private_key_bin = '0' * (256 - 30) + private_key_bin

        private_key_hex = binary_to_hex(private_key_bin)

        sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)
        public_key = sk.get_verifying_key().to_string().hex()

        compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64]
        compressed_public_key_bytes = bytes.fromhex(compressed_public_key)

        ripemd160_hash = hashlib.new('ripemd160')
        ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest())
        hashed_compressed_public_key = ripemd160_hash.digest().hex()


        if hashed_compressed_public_key == target_hash:
            print(private_key_hex)
            print("hash160:", hashed_compressed_public_key)
            print("Target hash found!")

            stop_event.set()
            break



def main():
    num_processes = 12
    processes = []
    stop_event = Event()

    start_time = time.time()

    for _ in range(num_processes):
        process = Process(target=worker, args=(14, 16, stop_event))
        processes.append(process)

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    if stop_event.is_set():
        for process in processes:
            process.terminate()

    end_time = time.time()
    execution_time_seconds = end_time - start_time

    hours = int(execution_time_seconds // 3600)
    minutes = int((execution_time_seconds % 3600) // 60)
    seconds = int(execution_time_seconds % 60)

    print(f"Time: {hours} h, {minutes} m, {seconds} s")



if __name__ == '__main__':
    main()

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Of course, it's just trying my luck. But who isn't trying their luck for hunters who don't have a lot of gpu? I believe that any other tool used by each of us hunters with only a small amount of resources is using random mode to search for private keys, so why not rule out some combinations with lower probability to try some private keys with higher probability?

[digaran]

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Of course, it's just trying my luck. But who isn't trying their luck for hunters who don't have a lot of gpu? I believe that any other tool used by each of us hunters with only a small amount of resources is using random mode to search for private keys, so why not rule out some combinations with lower probability to try some private keys with higher probability?

More importantly, why do you guys wasting your time on keys with no exposed public key? While you depend on luck trying to find #66, you could use your skills to find a way to reduce the range of public keys.😉

[tptkimikaze]

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Code:

000000000000000000000000000000000000000000000000000000003d94cd64
hash160: d39c4704664e1deb76c9331e637564c257d68a08
Target hash found!
Time: 0 h, 1 m, 28 s

Code:

import hashlib
import ecdsa
import random
import time
from multiprocessing import Process, Event

target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"

def binary_to_hex(bin_string):
    return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)


def worker(num_zeros, num_ones, stop_event):


    while True:
        if stop_event.is_set():
            break

        bits = ['0'] * num_zeros + ['1'] * (num_ones - 4)
        random.shuffle(bits)

        bits.insert(0, '1')
        bits.insert(1, '1')
        bits.insert(2, '1')
        bits.insert(3, '1')
        private_key_bin = ''.join(bits)

        private_key_bin = '0' * (256 - 30) + private_key_bin

        private_key_hex = binary_to_hex(private_key_bin)

        sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)
        public_key = sk.get_verifying_key().to_string().hex()

        compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64]
        compressed_public_key_bytes = bytes.fromhex(compressed_public_key)

        ripemd160_hash = hashlib.new('ripemd160')
        ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest())
        hashed_compressed_public_key = ripemd160_hash.digest().hex()


        if hashed_compressed_public_key == target_hash:
            print(private_key_hex)
            print("hash160:", hashed_compressed_public_key)
            print("Target hash found!")

            stop_event.set()
            break



def main():
    num_processes = 12
    processes = []
    stop_event = Event()

    start_time = time.time()

    for _ in range(num_processes):
        process = Process(target=worker, args=(14, 16, stop_event))
        processes.append(process)

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    if stop_event.is_set():
        for process in processes:
            process.terminate()

    end_time = time.time()
    execution_time_seconds = end_time - start_time

    hours = int(execution_time_seconds // 3600)
    minutes = int((execution_time_seconds % 3600) // 60)
    seconds = int(execution_time_seconds % 60)

    print(f"Time: {hours} h, {minutes} m, {seconds} s")



if __name__ == '__main__':
    main()

I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU.