Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Baskentliia]

Code:

while True:
    seed = random.getrandbits(161)
    random.seed(seed)
        

What do you guys think, why am I using a 2^161 bit number as a seed here? After a detailed study of all random processes, if the privatekeys are generated through truly random behavior, so the random.seed process to be the best, where we use an integer value as the seed. In this process, I came across a very important point. Suppose we are searching for a 2^66 bit key, then we will need to use atleast 2^67 bit integer as the seed where there are minimum 5 to a maximum of 20 such seeds that will generate the same private key, and if we use a smaller integer than a 2^67 bit number as the seed, then the possibility here will be less than 1%, whereas with a 2^67 bit number the possibility will 5% to 20% more..
Ex below:

Possibilities between 10 digit integer (1000000000,9999999999) as a seed

puzzle: 30 3d94cd64 Possibility : 15

Seed : 2052639366 KHex : 3d94cd64
Seed : 2323905501 KHex : 3d94cd64
Seed : 2889007956 KHex : 3d94cd64
Seed : 4803091600 KHex : 3d94cd64
Seed : 5331769548 KHex : 3d94cd64
Seed : 5694784015 KHex : 3d94cd64
Seed : 5792390035 KHex : 3d94cd64
Seed : 6994937489 KHex : 3d94cd64
Seed : 7090067961 KHex : 3d94cd64
Seed : 7452170991 KHex : 3d94cd64
Seed : 7858113595 KHex : 3d94cd64
Seed : 8992944053 KHex : 3d94cd64
Seed : 9469875945 KHex : 3d94cd64
Seed : 9524153307 KHex : 3d94cd64
Seed : 9684419123 KHex : 3d94cd64

puzzle: 34 34a65911 Possibility : 14

Seed : 1722252200 KHex : 34a65911
Seed : 2582475376 KHex : 34a65911
Seed : 3146132527 KHex : 34a65911
Seed : 4473671142 KHex : 34a65911
Seed : 5134795355 KHex : 34a65911
Seed : 5299026847 KHex : 34a65911
Seed : 5300649767 KHex : 34a65911
Seed : 5450281370 KHex : 34a65911
Seed : 6182674564 KHex : 34a65911
Seed : 6594937440 KHex : 34a65911
Seed : 7566838931 KHex : 34a65911
Seed : 8187842305 KHex : 34a65911
Seed : 8586215804 KHex : 34a65911
Seed : 9283526333 KHex : 34a65911

puzzle: 38 22382fac Possibility : 17

Seed : 1017443688 KHex : 22382fac
Seed : 1187626949 KHex : 22382fac
Seed : 1631857948 KHex : 22382fac
Seed : 1783928098 KHex : 22382fac
Seed : 2035912512 KHex : 22382fac
Seed : 2853290507 KHex : 22382fac
Seed : 3477553572 KHex : 22382fac
Seed : 3780988296 KHex : 22382fac
Seed : 3916938099 KHex : 22382fac
Seed : 5244479534 KHex : 22382fac
Seed : 6227911369 KHex : 22382fac
Seed : 6660947106 KHex : 22382fac
Seed : 7251913990 KHex : 22382fac
Seed : 7714721705 KHex : 22382fac
Seed : 7868071925 KHex : 22382fac
Seed : 9484955691 KHex : 22382fac
Seed : 9513527151 KHex : 22382fac

puzzle: 42 2a221c58 Possibility : 20

Seed : 1308278856 KHex : 2a221c58
Seed : 1379425098 KHex : 2a221c58
Seed : 2024762497 KHex : 2a221c58
Seed : 2609535036 KHex : 2a221c58
Seed : 2729740516 KHex : 2a221c58
Seed : 3275661006 KHex : 2a221c58
Seed : 3531204443 KHex : 2a221c58
Seed : 3598769574 KHex : 2a221c58
Seed : 4284691818 KHex : 2a221c58
Seed : 4709628279 KHex : 2a221c58
Seed : 7005421951 KHex : 2a221c58
Seed : 7183691932 KHex : 2a221c58
Seed : 7273191088 KHex : 2a221c58
Seed : 7576253169 KHex : 2a221c58
Seed : 7601317620 KHex : 2a221c58
Seed : 7871322617 KHex : 2a221c58
Seed : 8046353706 KHex : 2a221c58
Seed : 8891726737 KHex : 2a221c58
Seed : 9145147311 KHex : 2a221c58
Seed : 9800471746 KHex : 2a221c58

puzzle: 46 2ec18388 Possibility : 15

Seed : 1774835243 KHex : 2ec18388
Seed : 2937308955 KHex : 2ec18388
Seed : 3045928295 KHex : 2ec18388
Seed : 4641848762 KHex : 2ec18388
Seed : 5180804703 KHex : 2ec18388
Seed : 6035960426 KHex : 2ec18388
Seed : 7146220586 KHex : 2ec18388
Seed : 7156956377 KHex : 2ec18388
Seed : 7222816585 KHex : 2ec18388
Seed : 7545727131 KHex : 2ec18388
Seed : 8268637431 KHex : 2ec18388
Seed : 8709591535 KHex : 2ec18388
Seed : 9177834133 KHex : 2ec18388
Seed : 9287653195 KHex : 2ec18388
Seed : 9598790961 KHex : 2ec18388

puzzle: 50 22bd43c2 Possibility : 12

Seed : 1597954990 KHex : 22bd43c2
Seed : 1856859180 KHex : 22bd43c2
Seed : 1890522232 KHex : 22bd43c2
Seed : 2577736978 KHex : 22bd43c2
Seed : 6371285295 KHex : 22bd43c2
Seed : 6560037211 KHex : 22bd43c2
Seed : 7363977676 KHex : 22bd43c2
Seed : 7845176646 KHex : 22bd43c2
Seed : 8196730740 KHex : 22bd43c2
Seed : 9099833244 KHex : 22bd43c2
Seed : 9123680308 KHex : 22bd43c2
Seed : 9358095050 KHex : 22bd43c2

puzzle: 54 236fb6d5 Possibility : 19

Seed : 1663621769 KHex : 236fb6d5
Seed : 2206302900 KHex : 236fb6d5
Seed : 2597260125 KHex : 236fb6d5
Seed : 2615317878 KHex : 236fb6d5
Seed : 2730670030 KHex : 236fb6d5
Seed : 3007932907 KHex : 236fb6d5
Seed : 3326339756 KHex : 236fb6d5
Seed : 4309166434 KHex : 236fb6d5
Seed : 4488094942 KHex : 236fb6d5
Seed : 4847784268 KHex : 236fb6d5
Seed : 5906713946 KHex : 236fb6d5
Seed : 7356960439 KHex : 236fb6d5
Seed : 7626247310 KHex : 236fb6d5
Seed : 7749965571 KHex : 236fb6d5
Seed : 8485358824 KHex : 236fb6d5
Seed : 8889003136 KHex : 236fb6d5
Seed : 9026798147 KHex : 236fb6d5
Seed : 9651500975 KHex : 236fb6d5
Seed : 9731824276 KHex : 236fb6d5

puzzle: 58 2c675b85 Possibility : 08

Seed : 5195460147 KHex : 2c675b85
Seed : 5662132001 KHex : 2c675b85
Seed : 7714370860 KHex : 2c675b85
Seed : 8000772293 KHex : 2c675b85
Seed : 9136614552 KHex : 2c675b85
Seed : 9163101223 KHex : 2c675b85
Seed : 9216208020 KHex : 2c675b85
Seed : 9404555639 KHex : 2c675b85

puzzle: 62 363d541e Possibility : 16

Seed : 1249873414 KHex : 363d541e
Seed : 1740940588 KHex : 363d541e
Seed : 2496574222 KHex : 363d541e
Seed : 3468154272 KHex : 363d541e
Seed : 3712904381 KHex : 363d541e
Seed : 3887403068 KHex : 363d541e
Seed : 4463653170 KHex : 363d541e
Seed : 5570741169 KHex : 363d541e
Seed : 6613716909 KHex : 363d541e
Seed : 6918923634 KHex : 363d541e
Seed : 6922033862 KHex : 363d541e
Seed : 6988019520 KHex : 363d541e
Seed : 7204943190 KHex : 363d541e
Seed : 7676384085 KHex : 363d541e
Seed : 9416874734 KHex : 363d541e
Seed : 9962815469 KHex : 363d541e

puzzle: 66 ?? Possibility : ??

puzzle: 70 349b84b6 Possibility : 17

Seed : 1806955914 KHex : 349b84b6
Seed : 2415342823 KHex : 349b84b6
Seed : 4197018240 KHex : 349b84b6
Seed : 4347224256 KHex : 349b84b6
Seed : 5346252972 KHex : 349b84b6
Seed : 5352843046 KHex : 349b84b6
Seed : 5508295646 KHex : 349b84b6
Seed : 5894986884 KHex : 349b84b6
Seed : 6295082112 KHex : 349b84b6
Seed : 6439889966 KHex : 349b84b6
Seed : 7631063478 KHex : 349b84b6
Seed : 7701692142 KHex : 349b84b6
Seed : 8187722094 KHex : 349b84b6
Seed : 8403615774 KHex : 349b84b6
Seed : 9409843844 KHex : 349b84b6
Seed : 9835928266 KHex : 349b84b6
Seed : 9937976764 KHex : 349b84b6

you can check here with copy paste any integer from above

Code:

import random
while True:
    x = input('seed integer : ')
    seed_value = int(x)
    random.seed(seed_value)
    seed = str(seed_value)
    a = random.randrange(2**29, 2**30)
    random_start = "%00x" % a
    print('Seed : ' + str(x) + ' KHex : ' + str(random_start) + '\n')

Anyone have seen or experience with Bitcrack / fork for load starting points by file ?

Not sure what you are exactly wanting, but the easiest way is to create a Python script to feed the program starting ranges, and to keep track of said starting ranges. Not sure if starting ranges = starting points, but that is what I would do.

How to implement starting points..

Seed : 4379095358 | Khex : 258bf8e5

============================= Puzzle 66 Total keys = (36,893,488,147,419,103,231) ===================================

Unique Randomm range: 258bf8e5000000000:258bf8e5fffffffff
Total scanned ranges: 150430
Remning keys decimal: 32,198,884,667,768,991,167
Scanned keys decimal: 4,694,603,479,650,112,064
Remaining percentage: 87.27525177101334%
Scanneddd percentage: 12.724748228986655%

□ □ □ □ □ □ □ □ □ □ □ □ □ □ ■ □
□ ■ □ ■ ■ □ □ □ ■ □ ■ ■ ■ ■ ■ ■
■ □ □ □ ■ ■ ■ □ □ ■ □ ■ □ □ □ □
□ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □
□ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □


Lastt Found Address : 13zb1hQbmBqXcinyp85aMhRTABytw5VPUD  3B2B6D6B702DC4DB4
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 168


□ □ □ □ □ □ □ □ □ □ □ □ □ □ ■ ■
■ □ ■ ■ □ □ ■ □ ■ □ ■ ■ □ ■ ■ □
■ ■ □ ■ □ ■ ■ □ ■ □ ■ ■ □ ■ ■ ■
□ □ □ □ □ □ ■ □ ■ ■ □ ■ ■ ■ □ □
□ ■ □ □ ■ ■ □ ■ ■ □ ■ ■ □ ■ □ □


VanBitCrackenS v1.0
Keyspace start=258BF8E5000000000
Keyspace   end=258BF8E5FFFFFFFFF
Search: 16 prefixes (Lookup size 16) [Compressed]
CPU threads used: 0
GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
1118.150 MK/s (GPU 1118.150 MK/s) (2^35.81) [00:00:53 Elapsed Time][0]

Have a happy hunting.. And Please remember to include me in any success you achieve. Regards.

Note: Because I am feeling very tired now so if anyone is interested in getting all my data and scripts he can DM me

Can you share the ready code for puzzle 66? How do we run it for Puzzle 66?

[nomachine]

Can you share the ready code for puzzle 66? How do we run it for Puzzle 66?

something like this for his "lucky" python method

Code:

import random, secp256k1 as ice
puzzle = 66
target_hex = "20d45a6a762535700ce9e0b216e31994335db8a5"
target_binary = bytes.fromhex(target_hex)
while True:
    seed = random.getrandbits(161);random.seed(seed)
    A0 = random.randrange(2 ** (puzzle - 1), (2 ** puzzle) - 1)
    H160 = ice.privatekey_to_h160(0, True, A0)
    if H160 == target_binary:
        HEX = "%064x" % A0;wifc = ice.btc_pvk_to_wif(HEX)
        with open("KEYFOUNDKEYFOUND.txt", "a") as f:
          f.write(f'Seed: {seed}\n')
          f.write(f'Private key (wif) Compressed : {wifc}\n')
        break

[Akito S. M. Hosana]

It is immensely easier to guess Bill Gates' login and password to his bank account, and then guess his verification codes while trying to withdraw funds, than to find Puzzle from 66bit.

[WanderingPhilospher]

puzzle: 70 349b84b6 Possibility : 17

Seed : 1806955914 KHex : 349b84b6
Seed : 2415342823 KHex : 349b84b6
Seed : 4197018240 KHex : 349b84b6
Seed : 4347224256 KHex : 349b84b6
Seed : 5346252972 KHex : 349b84b6
Seed : 5352843046 KHex : 349b84b6
Seed : 5508295646 KHex : 349b84b6
Seed : 5894986884 KHex : 349b84b6
Seed : 6295082112 KHex : 349b84b6
Seed : 6439889966 KHex : 349b84b6
Seed : 7631063478 KHex : 349b84b6
Seed : 7701692142 KHex : 349b84b6
Seed : 8187722094 KHex : 349b84b6
Seed : 8403615774 KHex : 349b84b6
Seed : 9409843844 KHex : 349b84b6
Seed : 9835928266 KHex : 349b84b6
Seed : 9937976764 KHex : 349b84b6


you can check here with copy paste any integer from above

NGL, I do not get the same values when I copy and paste them in your python script.

BUT, your post got me tinkering with seeds. I'm running a test on a 24 bit key (DC2A04). Just letting it run to see how many matches I can get. From 0 up until I get bored lol. A few hundred so far. Highest one is 1477709519, so far.

[nomachine]

puzzle: 70 349b84b6 Possibility : 17

Seed : 1806955914 KHex : 349b84b6
Seed : 2415342823 KHex : 349b84b6
Seed : 4197018240 KHex : 349b84b6
Seed : 4347224256 KHex : 349b84b6
Seed : 5346252972 KHex : 349b84b6
Seed : 5352843046 KHex : 349b84b6
Seed : 5508295646 KHex : 349b84b6
Seed : 5894986884 KHex : 349b84b6
Seed : 6295082112 KHex : 349b84b6
Seed : 6439889966 KHex : 349b84b6
Seed : 7631063478 KHex : 349b84b6
Seed : 7701692142 KHex : 349b84b6
Seed : 8187722094 KHex : 349b84b6
Seed : 8403615774 KHex : 349b84b6
Seed : 9409843844 KHex : 349b84b6
Seed : 9835928266 KHex : 349b84b6
Seed : 9937976764 KHex : 349b84b6


you can check here with copy paste any integer from above

NGL, I do not get the same values when I copy and paste them in your python script.

BUT, your post got me tinkering with seeds. I'm running a test on a 24 bit key (DC2A04). Just letting it run to see how many matches I can get. From 0 up until I get bored lol. A few hundred so far. Highest one is 1477709519, so far.

Code:

import random
exp=30
while True:
    x = input('seed integer : ')
    seed_value = int(x)
    random.seed(seed_value)
    seed = str(seed_value)
    a = random.randrange(2**(exp-1), 2**exp)
    random_start = "%00x" % a
    print('Seed : ' + str(x) + ' KHex : ' + str(random_start) + '\n')

I put "exp" as a variable. If it is 30 for his 70-bit list, then it matches.

Seed integer: 1806955914
Seed: 1806955914 KHex: 349b84b6

I did not use decimal numbers as seeds. I had faster results with a sequence of bytes represented in Python's byte literal format using the function os.urandom(length).

Let's start from the the fact that all puzzles are created from 32 zeros in bytes
b'\x00' * 23 (twenty-three zeroes) + 9 bytes (for Puzzle 66)
or

Code:

b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

Puzzle 1 have 1 bytes on end that is not zero
Puzzle 10 have 2 bytes on end that is not zero
Puzzle 20 have 3 bytes on end that is not zero
Puzzle 40 have 5 bytes on end that is not zero
Puzzle 50 have 7 bytes on end that is not zero

Code:

Puzzle 65 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xa88\xb15\x05\xb2hg'
Puzzle 64 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x05\x1f'\xb0\x91\x12\xd4'
Puzzle 63 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00|\xce^\xfd\xac\xcfh\x08'

Puzzle 66 have 9 bytes on end that is not zero. *(66 bits is equal to 8.25 bytes.)

So, seed for puzzle 66 need to be 9 or 10 lenght in bytes

seed = os.urandom(10)

[zahid888]

NGL, I do not get the same values when I copy and paste them in your python script.

I don't know why this script isn't working for you all; it's working fine for me. Anyway, the seed will be a 10-digit number, and there are around 20 or more seeds capable of generating the same 30-bit starting point. I've tried many random and sequential 10-digit numbers as seeds and stored all the data that I've tested. There will be no repeats. Not sure when luck will be on my side

[nomachine]

NGL, I do not get the same values when I copy and paste them in your python script.

I don't know why this script isn't working for you all; it's working fine for me. Anyway, the seed will be a 10-digit number, and there are around 20 or more seeds capable of generating the same 30-bit starting point. I've tried many random and sequential 10-digit numbers as seeds and stored all the data that I've tested. There will be no repeats. Not sure when luck will be on my side

Here's way to do a byte-based search

Code:

import os, secp256k1 as ice
#Puzzle 66 config
start_bytes = bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xff\xff\xff\xff\xff\xff\xff\xff')
end_bytes = bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\xff\xff\xff\xff\xff\xff\xff\xff')
target_binary = b'\x20\xd4Zjv%5p\x0c\xe9\xe0\xb2\x16\xe3\x19\x9435\xb8\xa5'
while True:
    random_bytes = os.urandom(9)
    initial_bytes = b'\x00' * 23
    full_bytes = initial_bytes + random_bytes
    if start_bytes <= full_bytes <= end_bytes:
        A0 = int.from_bytes(full_bytes, byteorder='big')
        H160 = ice.privatekey_to_h160(0, True, A0)
        if H160 == target_binary:
            HEX = "%064x" % A0
            wifc = ice.btc_pvk_to_wif(HEX)
            with open("KEYFOUNDKEYFOUND.txt", "a") as f:
                f.write(f'Private key (wif) Compressed : {wifc}\n')
            break

 I have a collection of about 100 useless scripts. Because the problem is speed in Python.
Many cryptographic libraries, including Python secp256k1, expect numerical inputs (integers) for private keys, rather than raw byte sequences. Cryptographic libraries might be faster if they operated directly on bytes rather than converting between bytes and integers.

[zahid888]

NGL, I do not get the same values when I copy and paste them in your python script.

I don't know why this script isn't working for you all; it's working fine for me. Anyway, the seed will be a 10-digit number, and there are around 20 or more seeds capable of generating the same 30-bit starting point. I've tried many random and sequential 10-digit numbers as seeds and stored all the data that I've tested. There will be no repeats. Not sure when luck will be on my side

Here's way to do a byte-based search

Code:

import os, secp256k1 as ice
#Puzzle 66 config
start_bytes = bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xff\xff\xff\xff\xff\xff\xff\xff')
end_bytes = bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\xff\xff\xff\xff\xff\xff\xff\xff')
target_binary = b'\x20\xd4Zjv%5p\x0c\xe9\xe0\xb2\x16\xe3\x19\x9435\xb8\xa5'
while True:
    random_bytes = os.urandom(9)
    initial_bytes = b'\x00' * 23
    full_bytes = initial_bytes + random_bytes
    if start_bytes <= full_bytes <= end_bytes:
        A0 = int.from_bytes(full_bytes, byteorder='big')
        H160 = ice.privatekey_to_h160(0, True, A0)
        if H160 == target_binary:
            HEX = "%064x" % A0
            wifc = ice.btc_pvk_to_wif(HEX)
            with open("KEYFOUNDKEYFOUND.txt", "a") as f:
                f.write(f'Private key (wif) Compressed : {wifc}\n')
            break

 I have a collection of about 100 useless scripts. Because the problem is speed in Python.
Many cryptographic libraries, including Python secp256k1, expect numerical inputs (integers) for private keys, rather than raw byte sequences. Cryptographic libraries might be faster if they operated directly on bytes rather than converting between bytes and integers.

Relying solely on Python for 66-bit counting is a waste of time. However, if Python is used only to generate the starting or ending points and the rest of the counting is done through GPUs, it could be a more efficient approach. This is what I am trying to achieve.

The price of the private key for Puzzle 66 will be 5 BTC. Any interested miner will soon be able to purchase the private key from me. The dealing will take place in the public domain to eliminate any possibility of fraud. During this period, the creator reserves the right to sweep funds from Puzzle 66. 

[nomachine]

The price of the private key for Puzzle 66 will be 5 BTC. Any interested miner will soon be able to purchase the private key from me. The dealing will take place in the public domain to eliminate any possibility of fraud. During this period, the creator reserves the right to sweep funds from Puzzle 66. 

Good idea.   

[WanderingPhilospher]

Yeah, maybe I am doing something wrong lol:

Script copied/used:

Code:

import random
exp=30
while True:
    x = input('seed integer : ')
    seed_value = int(x)
    random.seed(seed_value)
    seed = str(seed_value)
    a = random.randrange(2**(exp-1), 2**exp)
    random_start = "%00x" % a
    print('Seed : ' + str(x) + ' KHex : ' + str(random_start) + '\n')

70 result and 30 result:

Code:

seed integer : 1806955914
Seed : 1806955914 KHex : 2a4dc25a

seed integer : 2052639366
Seed : 2052639366 KHex : 3e6b05ff

Top one is from 70 and second one is from 30. Neither match.

UPDATE: I figured it out. When I was running it in Python 2 IDLE, it did not match. But when I ran it in Python 3 IDLE, it did match. Interesting...

[ElonMusk_ia]

Why search for puzzle 66? Don't you think it's a waste of time?

[BackyardGeniusBro]

Dear puzzle creator:
We, the united super united, wish that you empty all addresses so that all these lost souls can go new ways.
Thank you, puzzle creator.

The game is over for now.
Please clear all addresses up to ~130 bits via exclusive/private mining so that no one can steal the funds by double spending.

Dear puzzle hater,

Im not sure who the super united is, but if you ran out of creativity or wana stay in a box and go a new way, please go by your self
Thank you, puzzle lover

[nomachine]

Imagine that Sam Bankman-Fried is the creator of the puzzle.

I think this is the winner of the most ridiculous post. 

[Akito S. M. Hosana]

Imagine that Sam Bankman-Fried is the creator of the puzzle.

I think this is the winner of the most ridiculous post. 

How do you know it's not him?

[kTimesG]

Hi everybody. Six months of work. I appeal to the creator. Tetris, criss-cross, 29=11=B, anchors 47=B, drawing and dec to hex is good, but why change the methodology and progress coefficients so harshly (he understands what I mean)? I went all in and I'm on edge. I know the formation of all the keys, or rather their initial values, but this did not bring it closer.

Edge of mental sanity. Let me guess, you also found a pattern in random noise. I also found a correlation between the solar winds activity affecting the Moon since the 1900s, taken on a monthly basis (excluding all Sundays, but not for leap years) and the progression of the private keys (when XORed with the distance between the Moon and the Earth at the moment of the sun burst). 0 = less than 50% chance of solar wind for that month. 1 = Sun boom chances were over 50% when the Moon was not covered by Earth. There are some minor inconsistencies though, but overall 95%  match. However the correlation only works up to puzzle 65. Dear creator, why did you change the coefficients so drastically?

[kTimesG]

If I post the information, the search range will be reduced for each wallet to a million initial options with a 40-bit brute force.
Two messages to the creator:
X   XX   XXX      XX
XX      XX     X      X


                                                                  HX  XX
XXY                         W                     VXX K     VB

Then what are you waiting for, instead of bragging here about your so called methodology not working as you expect? Brute forcing 40-bit whatevers takes from a few minutes to less than an hour on a single CPU.

[nomachine]

There are people who think the puzzle is a pay-me-I-pay-you joke. They believe that someone will pay them because they have information or resources that probably aren't a solution, because if they were, those people would have claimed the reward already and wouldn't be asking someone to pay them for their idea or solution. Why would someone rent a dedicated GPU cloud for puzzle searching if they could solve it themselves with the same one? Or try to sell a fancy, colorful Python puzzle script? 

[AlanJohnson]

There are people who think the puzzle is a pay-me-I-pay-you joke. They believe that someone will pay them because they have information or resources that probably aren't a solution, because if they were, those people would have claimed the reward already and wouldn't be asking someone to pay them for their idea or solution. Why would someone rent a dedicated GPU cloud for puzzle searching if they could solve it themselves with the same one? Or try to sell a fancy, colorful Python puzzle script? 

I heard that during the gold fever people who made best profit were not the ones digging the gold but those who were selling them shovels and other equipment.

[nomachine]

I don't sell shovels.

Here is Rust puzzle script that will work from 1-256bit :

main.rs

Code:

use bitcoin::address::Address;
use bitcoin::key::PrivateKey;
use bitcoin::network::NetworkKind;
use chrono::Local;
use clap::{App, Arg};
use hex;
use num::bigint::BigInt;
use num::traits::One;

use num_cpus;
use rand::Rng;
use rand::rngs::StdRng;
use rand::SeedableRng;
use std::fs::File;
use std::io::{self, Write};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc};
use std::convert::TryInto;
use threadpool::ThreadPool;

fn main() {
    // Print the current time when the script starts
    let current_time = Local::now();
    println!(
        "\x1b[38;5;226m[+] Puzzle search\n[+] Script started at:{}",
        current_time.format("%Y-%m-%d %H:%M:%S")
    );
    let matches = App::new("Puzzle Solver")
        .version("1.0")
        .arg(
            Arg::with_name("puzzle")
                .short('p')
                .long("puzzle")
                .value_name("PUZZLE")
                .help("Sets the puzzle number")
                .required(true)
                .takes_value(true),
        )
        .arg(
            Arg::with_name("address")
                .short('a')
                .long("address")
                .value_name("ADDRESS")
                .help("Sets the target address")
                .required(true)
                .takes_value(true),
        )
        .get_matches();

    let puzzle_str = matches.value_of("puzzle").unwrap();
    let puzzle: u128 = puzzle_str.parse().expect("Failed to parse puzzle number");
    let target_address = Arc::new(matches
        .value_of("address")
        .expect("Target address is required")
        .to_string());

    let range_start: BigInt = num::pow(BigInt::from(2), (puzzle - 1) as usize);
    let range_end: BigInt = num::pow(BigInt::from(2), puzzle as usize) - BigInt::one();

    let num_threads = num_cpus::get() as usize; // Convert to usize

    println!(
        "[+] concurrency:{}\n[+] puzzle:{}\n[+] from:{} to:{}\n[+] target:{}",
        num_threads, puzzle, range_start, range_end, target_address
    );

    let found_flag = Arc::new(AtomicBool::new(false));
    let pool = ThreadPool::new(num_threads.try_into().unwrap()); // Convert to usize

    // Handling termination signals
    let found_flag_clone = found_flag.clone();
    ctrlc::set_handler(move || {
        found_flag_clone.store(true, Ordering::Relaxed);
        std::process::exit(0); // Terminate the program
    })
    .expect("Error setting Ctrl-C handler");

    for _ in 0..num_threads {
        let target_address = Arc::clone(&target_address);
        let range_start_clone = range_start.clone();
        let range_end_clone = range_end.clone();
        let found_flag = found_flag.clone();
        let pool_clone = pool.clone();
        pool.execute(move || {
            let mut rng = StdRng::from_entropy();
            random_lookfor(&rng.gen_range(range_start_clone.clone()..range_end_clone.clone()), &range_end_clone, &target_address, &found_flag, &pool_clone);
        });
    }

    pool.join();
}

fn random_lookfor(
    range_start: &BigInt,
    range_end: &BigInt,
    target_address: &Arc<String>,
    found_flag: &Arc<AtomicBool>,
    _pool: &ThreadPool,
) {
    let mut rng = StdRng::from_entropy();
    let secp = bitcoin::secp256k1::Secp256k1::new();

    loop {
        let key: BigInt = rng.gen_range(range_start.clone()..range_end.clone());
        let private_key_hex = format!("{:0>64x}", key);
        let private_key_bytes =
            hex::decode(&private_key_hex).expect("Failed to decode private key hex");

        let private_key = PrivateKey {
            compressed: true,
            network: NetworkKind::Main,
            inner: bitcoin::secp256k1::SecretKey::from_slice(&private_key_bytes)
                .expect("Failed to create secret key from slice"),
        };

        let public_key = private_key.public_key(&secp);
        let address = Address::p2pkh(&public_key, NetworkKind::Main).to_string();
        // print!("[+] key:{}\r", key);
        // io::stdout().flush().unwrap();

        // Check if a match has been found by another thread
        if found_flag.load(Ordering::Relaxed) {
            break;
        }

        if address == **target_address {
            let current_time = Local::now();
            let line_of_dashes = "-".repeat(80);
            println!(
                "\n[+] {}\n[+] KEY FOUND! {}\n[+] decimal: {} \n[+] private key: {} \n[+] public key: {} \n[+] address: {}\n[+] {}",
                line_of_dashes,
                current_time.format("%Y-%m-%d %H:%M:%S"),
                key,
                private_key,
                public_key,
                address,
                line_of_dashes
            );

            // Set the flag to true to signal other threads to exit
            found_flag.store(true, Ordering::Relaxed);

            if let Ok(mut file) = File::create("KEYFOUNDKEYFOUND.txt") {
                let line_of_dashes = "-".repeat(130);
                writeln!(
                    &mut file,
                    "\n{}\nKEY FOUND! {}\ndecimal: {} \nprivate key: {} \npublic key: {} \naddress: {}\n{}",
                    line_of_dashes,
                    current_time.format("%Y-%m-%d %H:%M:%S"),
                    key,
                    private_key,
                    public_key,
                    address,
                    line_of_dashes
                )
                .expect("Failed to write to file");
            } else {
                eprintln!("Error: Failed to create or write to KEYFOUNDKEYFOUND.txt");
            }
            io::stdout().flush().unwrap();
            break;
        }
    }
}

Cargo.toml

Code:

[package]
name = "puzzle"
version = "0.1.0"
edition = "2021"

[dependencies]
num = "0.4.1"
num-traits = "0.2"
num-bigint = { version = "0.4.4", features = ["rand"] }
threadpool = "1.8.1"     
bitcoin = "0.32.2"
hex = "0.4.3"
rand = "0.8.5"
secp256k1 = "0.29.0"
num_cpus = "1.16.0"
chrono = "0.4.38"
clap = "3.0"
ctrlc = "3.4.4"

Build program

Code:

cargo build --release --target=x86_64-unknown-linux-gnu

it will be generated in
./target/x86_64-unknown-linux-gnu/release/puzzle


Usage example

Code:

./puzzle -p 20 -a 1HsMJxNiV7TLxmoF6uJNkydxPFDog4NQum
./puzzle -p 30 -a 1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
./puzzle -p 66 -a 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so 
./puzzle -p 130 -a 1Fo65aKq8s8iquMt6weF1rku1moWVEd5Ua 

 it's not exactly like C, but it's 10 times faster than Python.

time ./puzzle -p 30 -a 1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps

• Puzzle search
• Script started at:2024-07-07 21:45:29
• concurrency:12
• puzzle:30
• from:536870912 to:1073741823
• target:1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
• --------------------------------------------------------------------------------
• KEY FOUND! 2024-07-07 21:46:30
• decimal: 1033162084
• private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M8diLSC5MyERoW
• public key: 030d282cf2ff536d2c42f105d0b8588821a915dc3f9a05bd98bb23af67a2e92a5b
• address: 1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
• --------------------------------------------------------------------------------

real   1m0.850s
user   10m54.448s
sys   0m0.196s


There are various types of RNGs in Rust, each with its own set of trade-offs and speed.

Here is a list:

https://rust-random.github.io/book/guide-rngs.html

To determine the fastest RNG for this specific use case, you might need to benchmark various RNGs within the context of this application. The next stage is to implement kangaroo full in Rust

[kTimesG]

I don't sell shovels.

Here is Rust puzzle script that will work from 1-256bit :

...

There are various types of RNGs in Rust, each with its own set of trade-offs and speed.

To determine the fastest RNG for this specific use case, might need to benchmark various RNGs within the context of this application. . .

More than as a nice skill exercise to write a Rust program, there's zero benefit. It's like reducing the time needed to walk to the edge of the galaxy to the time needed to walk to Alpha Centauri. Less, but still totally unfeasible.

The bottleneck is still computing the scalar multiplication and hashing that stuff. RNG speed is a grain in the sand while the rest of the program is the entire beach.

The next stage is kangaroo full in Rust.

Good luck. Even the fastest C implementation for the actual jumps is hundreds of times slower than CUDA. A lot more watts/jump price. I'm at 5500 M jumps/s on an RTX 6000 Ada, and planning on doubling the throughput soon by switching to floats. While on an i9 13700H I could never reach more than 12 M jumps/s on a single core (and this was using SIMD, carry-free instructions, batch inversion, etc).