Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 86.

madogss

newbie

Activity: 38

Merit: 0

Quote from: maylabel on June 06, 2024, 08:06:08 PM

you need to know the compressed publickey hex66 to run.
However I don't know how to get this. I tried publichash like
Public Key Hash: 20d45a6a762535700ce9e0b216e31994335db8a5

but I can't run because is not the the public key in the format the BSGS need.
Someone know how to do this?

you get the public key when the address sends an outgoing transaction if there isn't one then you cannot get the public key.

maylabel

newbie

Activity: 24

Merit: 0

Quote from: albert0bsd on May 21, 2024, 05:54:21 PM

Quote from: aminsolhi on May 20, 2024, 06:57:42 PM

keyhunt not good

you should learn to configure it, defaul thread subrange is 32 bits, for small ranges with multiple threads you should lower the N value with "-n number" if the range is less than 1 Million keys you should use -n 0x10000
where 0x10000 its a 16 bits subrange per thread

Look

https://talkimg.com/images/2024/05/21/1iVIH.png

Found i less than a second

If someon knows, I will appreciate.
On KeyHunt, BSGS technique we have
https://github.com/albertobsd/keyhunt/tree/main?tab=readme-ov-file#bsgs-mode-baby-step-giant-step

Quote

bsgs mode (baby step giant step)
Keyhunt implement the BSGS algorithm to search privatekeys for a known public key.

The input file need to have a list of publickeys compress or uncompress those publickey can be mixed in the same file, one public key per line and any other word followed by an space is ignored example of the file:

you need to know the compressed publickey hex66 to run.
However I don't know how to get this. I tried publichash like
Public Key Hash: 20d45a6a762535700ce9e0b216e31994335db8a5

but I can't run because is not the the public key in the format the BSGS need.
Someone know how to do this?

AliBah

newbie

Activity: 39

Merit: 0

guys, we had a sample on range 66 for test speed and time to find private key here, anybody knows which post was that?

Cballz

newbie

Activity: 1

Merit: 0

Quote from: citb0in on April 07, 2024, 02:05:45 PM

Quote from: Filip8472 on April 07, 2024, 01:52:12 PM

Hi guys, im new here, now i use rotor-cuda i have RTX 3050 (650Mk/s) and i trying puzzle #67 because I'll have a head start when puzzle #66 is solved, is this a good approach or im dumb ? sorry for my english

does not change anything. When pubkey is known puz67 is cracked also within seconds. In my example with a GPU very similar to yours --> 63 seconds

Cheers!
citb0in

How is it possible? i understand.. nevermind. it just dawned on me. once they know the pubkey they already know the range. but still maybe i dont understand how they will get it. cant the person just sweep it to a new wallet? could you tell me what u use? i started with vanity, now keyhunt and i just started trying collider.exe but i dont know what works best yet so im looking for some pointers. averaging a billion a second on address and 300 pkeys on bsgs/xpoints. but im fiding xpoints missing my test address so not liking it too much. What would you recommend? Im brand ne here and I LOVE THIS SHIT MAN.. Have a great day!!!!! Jason Huh

If you could have one pick? Keyhunt, Vanity, Bitcrack, Collider... What would it be? And what mode would you use? Addresses, BSGS etc. Also it be cool if you listed your stats a bit. Not top stats but average stats of what you get normally... Brand new here. Just wanted to take the time to thank all of u guys. Especially Albert. Even with the language barrier I have by far learned the most from you. Whatever I win I got you bro.. Shocked

  Jay C

Also Albert does your program run the threading like this? Im uessing it does but idk...

GPU : GPU #0 NVIDIA RTX A4000 (48x0 cores) Grid(1536x512)

GPU 0 Thread 000000: 0000000000000000000000000000000000000000000000032900000000000000 :
   000000000000000000000000000000000000000000000003290011EAAAAAAAAA
GPU 0 Thread 000001: 000000000000000000000000000000000000000000000003290011EAAAAAAAAA :
   000000000000000000000000000000000000000000000003290023D555555554
GPU 0 Thread 000002: 000000000000000000000000000000000000000000000003290023D555555554 :
   000000000000000000000000000000000000000000000003290035BFFFFFFFFE
   .
GPU 0 Thread 786431: 000000000000000000000000000000000000000000000003FFFFEE15554D5556 :
   000000000000000000000000000000000000000000000003FFFFFFFFFFF80000

"you gotta let it hurt b4 you let it heal"

nomachine

member

Activity: 499

Merit: 38

Quote from: ilkerc on June 01, 2024, 10:49:01 AM

One lucky person gets the full prize. Bitcoin puzzle 66, 67 and 68 are supported.

I strongly advise against downloading and running precompiled binaries from unfamiliar sources. Without open-source code, there's no way to verify what a program is doing behind the scenes.

Malicious software could potentially spy on your system, accessing your hard drive or RAM, and extracting sensitive data like passwords or wallet files to remote servers. Always avoid running .dll or .exe files from untrusted origins.
Whenever possible, consider compiling binaries from their source code.

Ultimately, the decision of whom to trust is yours, but consider this a friendly warning.

Usually, where work is done in vain, there is some malicious intent. The goal is not solely the puzzle, but rather secondary aspects crafted as a hook for those interested.

Once the public key for Puzzle 66 is revealed, it will be cracked by a simple bot within 63 seconds.
I'm not sure whether the person involved will be celebrating or crying in the next 20 minutes . . .

ilkerc

newbie

Activity: 8

Merit: 2

Hello, you can join the "btcpuzzle.info" website with the 100% open source "bitcrackrandomiser" tool. We haven't completed a year yet, but we have completed 11% of the keys. (in Puzzle 66)

Btcpuzzle.info is a solo pool, but the scanned ranges are shared. One lucky person gets the full prize. Bitcoin puzzle 66, 67 and 68 are supported.

BTC Puzzle website;
https://btcpuzzle.info/

Github repo;
https://github.com/ilkerccom/bitcrackrandomiser

Thanks. Roll Eyes

nomachine

member

Activity: 499

Merit: 38

Quote from: Fllear on May 29, 2024, 09:53:08 AM

I searched and couldn't find anything in C++.

You can use VanitySearch to generate whatever you want if you know how Grin

Code:

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

For example

main.cpp

Code:

#include "SECP256k1.h"
#include "Int.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int numThreads = 128; // Adjust this number based on your CPU cores

// Function to generate keys and check for a specific public key
void generateKeysAndCheckForPublicKey(const Int& minKey, const Int& maxKey, std::shared_ptr secp256k1, const std::string& targetPublicKey, int threadIndex, int step) {
   Int privateKey = minKey;
   privateKey.Add(threadIndex);
   Point publicKey;
   std::string pubKeyStr;
   std::string wifc;

   while (true) {
   publicKey = secp256k1->ComputePublicKey(&privateKey);
   pubKeyStr = secp256k1->GetPublicKeyHex(true, publicKey); // get the public key in hex format

   // Convert pubKeyStr to lowercase
   std::transform(pubKeyStr.begin(), pubKeyStr.end(), pubKeyStr.begin(), ::tolower);

   wifc = secp256k1->GetPrivAddress(true, privateKey);

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

   // Check if the generated public key matches the target public key
   if (pubKeyStr == targetPublicKey) {
   time_t currentTime = std::time(nullptr);

   // Format the current time into a human-readable string
   std::tm tmStruct = *std::localtime(¤tTime);
   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 Key: " << pubKeyStr;
   file << "\nPrivatekey (dec): " << privateKey.GetBase10();
   file << "\nPrivatekey Compressed (wif): " << wifc;
   file << "\n----------------------------------------------------------------------------------------------------------------------------------";
   file.close();
   }
   }

   privateKey.Add(step);

   if (privateKey.IsGreater(const_cast(&maxKey))) {
   break;
   }
   }
}

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

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

   Int minKey;
   Int maxKey;
   // Configuration for the Puzzle 20
   minKey.SetBase10("524287");
   maxKey.SetBase10("1048575");
   std::string targetPublicKey = "033c4a45cbd643ff97d77f41ea37e843648d50fd894b864b0d52febc62f6454f7c"; // Puzzle 20 public key

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

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

   for (int i = 0; i < numThreads; ++i) {
   threads.emplace_back(generateKeysAndCheckForPublicKey, std::ref(minKey), std::ref(maxKey), secp256k1, std::ref(targetPublicKey), i, numThreads);
   }

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

   return 0;
}

copy and paste this into main.cpp

make

./VanitySearch

PUZZLE SOLVED: 2024-05-29 21:20:42
WIF: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rHfuE2Tg4nJW

pbies

full member

Activity: 297

Merit: 133

Quote from: Fllear on May 29, 2024, 12:06:53 PM

I know how and what is generated. I need this for my experiment, but at this rate it's a perversion. And my hardware is quite powerful, 72 cores and 128GB of RAM. The same keyhunt, when brute force, produces 350 million keys at maximum load. But I need exactly this algorithm, hex separately from the public key. So that when I found a public key from the list, I knew its hex.

Producing hex numbers is fast. But converting them to public keys is not. You use SHA256 here, mostly twice. This is resource demanding and it is not only adding two numbers.
Second: you need to look up the public key in a table, good if it will be in RAM, but still you need to search at least a b-tree, complexity O(log(N)).

Fllear

newbie

Activity: 5

Merit: 0

Quote from: kTimesG on May 29, 2024, 10:55:16 AM

Quote from: Fllear on May 29, 2024, 09:53:08 AM

I searched and couldn't find anything in C++. The computer is capable of generating at least 100 million keys per second. But all the scripts I found are very slow. You just need the hex to be in a separate file and the public keys to be in a separate file. Thank you very much in advance if anyone decides to help.

What world do you live in, in which the computer can generate "at least 100 million keys per second", I wanna move there.

If you are simply talking about a private key, then a "computer" can generate "number of cores" * "core frequency" private keys per second, but what the hell are you gonna do with a bunch of numbers?

Do you understand the difference between a public key and a private key, and how the first one is computed through the second one? I mean, all the math that's required is not some simple a + b.

I know how and what is generated. I need this for my experiment, but at this rate it's a perversion. And my hardware is quite powerful, 72 cores and 128GB of RAM. The same keyhunt, when brute force, produces 350 million keys at maximum load. But I need exactly this algorithm, hex separately from the public key. So that when I found a public key from the list, I knew its hex.

pbies

full member

Activity: 297

Merit: 133

Quote from: Fllear on May 29, 2024, 09:53:08 AM

...

I think you fall for some programs that you've seen which were generating huge amounts of keys per second,
and you think this is possible,
but they were fake.

kTimesG

member

Activity: 165

Merit: 26

Quote from: Fllear on May 29, 2024, 09:53:08 AM

I searched and couldn't find anything in C++. The computer is capable of generating at least 100 million keys per second. But all the scripts I found are very slow. You just need the hex to be in a separate file and the public keys to be in a separate file. Thank you very much in advance if anyone decides to help.

What world do you live in, in which the computer can generate "at least 100 million keys per second", I wanna move there.

If you are simply talking about a private key, then a "computer" can generate "number of cores" * "core frequency" private keys per second, but what the hell are you gonna do with a bunch of numbers?

Do you understand the difference between a public key and a private key, and how the first one is computed through the second one? I mean, all the math that's required is not some simple a + b.

Fllear

newbie

Activity: 5

Merit: 0

Tell me, is there a quick python code for generating a hex private key in the required range? So that the result is saved in a text file. Well, then maybe there is a script to create a public key from this text file, also with saving. I just found some, but they are very slow, they generate 100 million hex per day, as well as public keys.

I searched and couldn't find anything in C++. The computer is capable of generating at least 100 million keys per second. But all the scripts I found are very slow. You just need the hex to be in a separate file and the public keys to be in a separate file. Thank you very much in advance if anyone decides to help.

First I generate hex with this code.

Code:

import random
path = './file.txt'
start = 21778071482940061661655974875633165533184

stop = 27222589353675077077069968594541456916480

while start <= stop:
step = random.randint(start,stop)
start + step
print('0000000000000000000000000000000' + hex(step).lstrip("0x"))
with open(path, 'w+') as f:
f.write('0000000000000000000000000000000' + hex(step).lstrip("0x"))

Relatively fast, but still slow

Next, I generate wif from hex

Code:

import binascii, hashlib, base58, sys
arq = open('WIF.txt', 'w')

def convert(z):

private_key_static = z

extended_key = "80"+private_key_static+"01"

first_sha256 = hashlib.sha256(binascii.unhexlify(extended_key)).hexdigest()

second_sha256 = hashlib.sha256(binascii.unhexlify(first_sha256)).hexdigest()

final_key = extended_key+second_sha256[:8]

WIF = base58.b58encode(binascii.unhexlify(final_key)).decode ('ascii')

arq.write("%s \n" % WIF)

with open("file.txt") as file:
for line in file:
print (str.strip(line))
convert(str.strip(line))

And it's sooooo slow

And at the end I generate a public key from wif

from bitcoin import *

Code:

with open("WIF.txt") as f:
for line in f:
print(privtopub((line.strip())))

I won’t do anything this way even before retirement.

viljy

hero member

Activity: 1736

Merit: 857

Quote from: nomachine on May 26, 2024, 06:08:10 PM

Quote from: viljy on May 25, 2024, 06:50:08 AM

Is this the speed at which public keys are checked in the hash table (using a bloom filter?)

Yes.

I am runung custom compiled BSGS with 1TB RAM on AMD EPYC x2 (128 cores)

bpfile size ~704 GB
bloom size ~110.47 GB

Wow, that's a cool config you have. When I tried to search for keys before, I did not reach a speed of more than 2 Ekeys

nomachine

member

Activity: 499

Merit: 38

Quote from: viljy on May 25, 2024, 06:50:08 AM

Is this the speed at which public keys are checked in the hash table (using a bloom filter?)

Yes.

I am runung custom compiled BSGS with 1TB RAM on AMD EPYC x2 (128 cores)

bpfile size ~704 GB
bloom size ~110.47 GB

dextronomous

full member

Activity: 431

Merit: 105

Quote from: viljy on May 25, 2024, 06:50:08 AM

Quote from: nomachine on May 23, 2024, 11:40:52 PM

I have ~120 Ekeys/s in BSGS/keyhunt on AMD after used the AOCC compiler Grin

Is this the speed at which public keys are checked in the hash table (using a bloom filter?), or is this the real speed at which the processor generates public keys?
Quite a high speed even for BSGS on a video card

Hi there nomachine, you got a way for a working make file already done for this one , for amd..
right now i have not yet been able to do so, little time many works, thanks for your effort.

aminsolhi

newbie

Activity: 15

Merit: 0

Quote from: WanderingPhilospher on May 25, 2024, 10:15:22 AM

Quote from: aminsolhi on May 22, 2024, 05:15:31 AM

Quote from: albert0bsd on May 21, 2024, 05:54:21 PM

Quote from: aminsolhi on May 20, 2024, 06:57:42 PM

keyhunt not good

you should learn to configure it, defaul thread subrange is 32 bits, for small ranges with multiple threads you should lower the N value with "-n number" if the range is less than 1 Million keys you should use -n 0x10000
where 0x10000 its a 16 bits subrange per thread

Look

https://talkimg.com/images/2024/05/21/1iVIH.png

Found i less than a second

are you key hunt creator?
nice too meet you
It was my mistake, I apologize, dear friend
ok , thank you
I meant https://github.com/WanderingPhilosopher/KeyHuntCudaClient
i use of first version keyhunt cuda

Zero clues of how or what you ran, but with a single CPU core, using keyhunt-cuda, it is found pretty much as the program starts:

Code:

KeyHunt-Cuda v1.08

COMP MODE : COMPRESSED
COIN TYPE : BITCOIN
SEARCH MODE : Single Address
DEVICE : CPU
CPU THREAD : 1
SSE : YES
RKEY : 0 Mkeys
MAX FOUND : 65536
BTC ADDRESS : 1E5V4LbVrTbFrfj7VN876DamzkaNiGAvFo
OUTPUT FILE : Found.txt

Start Time : Sat May 25 10:11:49 2024
Global start : 20000000000000000 (66 bit)
Global end : 21000000000000000 (66 bit)
Global range : 1000000000000000 (61 bit)

[00:00:02] [CPU+GPU: 5.28 Mk/s] [GPU: 0.00 Mk/s] [C: 0.000000 %] [R: 0] [T: 10,706,944 (24 bit)] [F: 1]

BYE

SO maybe you entered wrong things/flags when trying to run the program.

this is 1 milion key after start 200000000000f4240
and this is p2ph compressed public key : 1E5V4LbVrTbFrfj7VN876DamzkaNiGAvFo

KeyHunt-Cuda.exe -t 0 -g --gpui 0 --gpux 24,256 -m address --coin BTC --range 20000000000000000:40000000000000000 1E5V4LbVrTbFrfj7VN876DamzkaNiGAvFo

my keyhunt cuda speed is 60 Mk/s . In fact, Cuda should find it in less than 1 second, but it takes about 1:40 minute

KeyHunt-Cuda.exe -t 0 -g --gpui 0 --gpux 24,256 -m address --coin BTC --range 20000000000000000:40000000000000000 1E5V4LbVrTbFrfj7VN876DamzkaNiGAvFo

KeyHunt-Cuda v1.07

COMP MODE : COMPRESSED
COIN TYPE : BITCOIN
SEARCH MODE : Single Address
DEVICE : GPU
CPU THREAD : 0
GPU IDS : 0
GPU GRIDSIZE : 24x256
SSE : YES
RKEY : 0 Mkeys
MAX FOUND : 65536
BTC ADDRESS : 1E5V4LbVrTbFrfj7VN876DamzkaNiGAvFo
OUTPUT FILE : Found.txt

Start Time : Sun May 26 14:04:50 2024
Global start : 20000000000000000 (66 bit)
Global end : 40000000000000000 (67 bit)
Global range : 20000000000000000 (66 bit)

GPU : GPU #0 Quadro P1000 (4x128 cores) Grid(24x256)

[00:01:36] [CPU+GPU: 62.21 Mk/s] [GPU: 62.21 Mk/s] [C: 0.000000 %] [R: 0] [T: 5,976,883,200 (33 bit)] [F: 0]

The problem is that Cuda performs the same task in all graphics cores in parallel and repetitively, and instead of the cores each helping the program, each of them repeats the same task as an island, for example, each core in parallel from the same start. He does and moves forward. And maybe in the best case, it divides the entire collection into the number of cores and each core starts working in that interval, in this case, once you exit the program, all your efforts will end in an unknown place, which will be used the next time you run the program. You don't know where to start

Of course, it seems that you are using a higher version of this software v1.08. But anyway, I have to tell the truth. You have written a very good software. I really enjoyed your code ideas.

madogss

newbie

Activity: 38

Merit: 0

Quote from: Tepan on May 25, 2024, 02:05:37 PM

hi guys! who can help me to develop rust coding language?! (don't judge my statement and result, since i just new for learning this puzzle and trying new stuff)

i run this like 4-5 hours straight, i use pool keyspace and multi thread, the search only use CPU, let's find out can develop it with GPU power.

it's sequential and not random.

the thread is dividing key ranges and make the 1,5 bytes changed from left padding following how many thread are used.

Puzzle search
Script started at: 2024-05-25 20:56:03.700485 +07:00
from:0x23000000000000000 to:0x3ffffffffffffffff
target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

0000000000000000000000000000000000000000000000035200000002cc179e| 13zbaq4dADzLenZB6VdSdmAaqV8TABkHEf

average current speed is 15.000 Key/sec for each thread.

with some GPU power, i think my codes (?) can solve that in couple months.
my codes still make some bug, the address display is misleading the corresponding of private key, but it's still same prefix.
all of that still can search the matched, but the displaying of progress is not correct.
🙏🏻

example of pre-run.

000000000000000000000000000000000000000000000003c600000000002b0f | 13zbpbczKXAcx9q4NvTuEa5szGu3 000000000000000000000000000000000000000000000003520000000000a039 | 13zbNacfa9Nrz8YttQbzLVqT7y4w 000000000000000000000000000000000000000000000003c60000000000d456 | 13zbFwGk1JussoSK3gax39256VBu 000000000000000000000000000000000000000000000002de000000000103a3 | 13zbt3NfsVUjJu8FQWxFfxdePAFP 0000000000000000000000000000000000000000000000026a00000000010bd3 | 13zbix1E22g4FRk5hUcoMV1Hhvpd 000000000000000000000000000000000000000000000002de0000000001333e | 13zbDQnUKS1N8AqmynykC1QYNgwc 000000000000000000000000000000000000000000000002de00000000013e02 | 13zb7xLuqjuPKdbGt7rshDEjdprK 00000000000000000000000000000000000000000000000352000000000168ae | 13zbm8dR61ur1GqnQEmjrRsM5knP 000000000000000000000000000000000000000000000002300000000001923c | 13zbpdWGSwZpHK2zyR2o5XqgfXdv 0000000000000000000000000000000000000000000000026a0000000001c928 | 13zbp7u1bEeK94RCMtsvuNtqBrYo 0000000000000000000000000000000000000000000000038c0000000001e94a | 13zb56DAy494Drdngk2YchYRNfvF 0000000000000000000000000000000000000000000000023000000000023728 | 13zbFaEpeoY7Hrx6sTLdM3ZvvUW5 0000000000000000000000000000000000000000000000031800000000023ade | 13zbtT9na4bJdYoexnZ6YSt6KDHp

I believe Keyhuntcuda2 from siupune has this functioning on the gpu

kTimesG

member

Activity: 165

Merit: 26

Quote from: viljy on May 25, 2024, 06:50:08 AM

Quote from: nomachine on May 23, 2024, 11:40:52 PM

I have ~120 Ekeys/s in BSGS/keyhunt on AMD after used the AOCC compiler Grin

Is this the speed at which public keys are checked in the hash table (using a bloom filter?), or is this the real speed at which the processor generates public keys?
Quite a high speed even for BSGS on a video card

120 exakeys = 120.000.000.000 gigakeys

Pretending some 4Ghz CPU generates, sequentially, one key per cycle (it doesn't, more like one key over 300 cycles on average, and that's with all possible optimizations) it would still take 30.000.000.000 CPU cores to reach that speed.

Or (300 cycles/key): 9.000.000.000.000 cores that are running all at 100% with no OS, nothing else running, all working at full speed doing nothing except crunching numbers inside the CPU registers.

I think maybe that speed reflects space coverage rather than operating time, and space coverage speed is logarithmic not linear.

Tepan

jr. member

Activity: 77

Merit: 1

Quote from: Tepan on May 25, 2024, 02:05:37 PM

hi guys! who can help me to develop rust coding language?! (don't judge my statement and result, since i just new for learning this puzzle and trying new stuff)

i run this like 4-5 hours straight, i use pool keyspace and multi thread, the search only use CPU, let's find out can develop it with GPU power.

it's sequential and not random.

the thread is dividing key ranges and make the 1,5 bytes changed from left padding following how many thread are used.

Puzzle search
Script started at: 2024-05-25 20:56:03.700485 +07:00
from:0x23000000000000000 to:0x3ffffffffffffffff
target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

0000000000000000000000000000000000000000000000035200000002cc179e| 13zbaq4dADzLenZB6VdSdmAaqV8TABkHEf

average current speed is 15.000 Key/sec for each thread.

with some GPU power, i think my codes (?) can solve that in couple months.
my codes still make some bug, the address display is misleading the corresponding of private key, but it's still same prefix.
all of that still can search the matched, but the displaying of progress is not correct.
🙏🏻

example of pre-run.

000000000000000000000000000000000000000000000003c600000000002b0f | 13zbpbczKXAcx9q4NvTuEa5szGu3 000000000000000000000000000000000000000000000003520000000000a039 | 13zbNacfa9Nrz8YttQbzLVqT7y4w 000000000000000000000000000000000000000000000003c60000000000d456 | 13zbFwGk1JussoSK3gax39256VBu 000000000000000000000000000000000000000000000002de000000000103a3 | 13zbt3NfsVUjJu8FQWxFfxdePAFP 0000000000000000000000000000000000000000000000026a00000000010bd3 | 13zbix1E22g4FRk5hUcoMV1Hhvpd 000000000000000000000000000000000000000000000002de0000000001333e | 13zbDQnUKS1N8AqmynykC1QYNgwc 000000000000000000000000000000000000000000000002de00000000013e02 | 13zb7xLuqjuPKdbGt7rshDEjdprK 00000000000000000000000000000000000000000000000352000000000168ae | 13zbm8dR61ur1GqnQEmjrRsM5knP 000000000000000000000000000000000000000000000002300000000001923c | 13zbpdWGSwZpHK2zyR2o5XqgfXdv 0000000000000000000000000000000000000000000000026a0000000001c928 | 13zbp7u1bEeK94RCMtsvuNtqBrYo 0000000000000000000000000000000000000000000000038c0000000001e94a | 13zb56DAy494Drdngk2YchYRNfvF 0000000000000000000000000000000000000000000000023000000000023728 | 13zbFaEpeoY7Hrx6sTLdM3ZvvUW5 0000000000000000000000000000000000000000000000031800000000023ade | 13zbtT9na4bJdYoexnZ6YSt6KDHp

my search techniques uses this
2^31 and 2^36
(36 bit)
MacBook-Pro:Desktop tepan$ python3 subs.py
Enter the range x: 31
Enter the range y: 36

> 0x91000000 <

let's hunt.

let begin: u128 = 0x910000000;
let end: u128 = 0x9ffffffff;

const TARGET: &str = "1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1";

result :

Puzzle search
Script started at: 2024-05-26 02:25:21.816449 +07:00
from:0x910000000 to:0x9ffffffff
target:1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1

00000000000000000000000000000000000000000000000000000009f7a02888| 1Be2JoBBasXePHijh1AD1FK5Wsui 00000000000000000000000000000000000000000000000000000009f3702fc4| 1Be2m52dDvKNf2wrvbvSoh4V4t8Q 00000000000000000000000000000000000000000000000000000009e2b0702a| 1Be2DebJWkfJWXb8cszjA8mN6fvh 00000000000000000000000000000000000000000000000000000009e6e07a23| 1Be2wkS3jkyDGWnVpiNXVzUYdTtY 00000000000000000000000000000000000000000000000000000009eb10e589| 1Be2f5NaU8Qv35nPzJk4S6Jntzvs 00000000000000000000000000000000000000000000000000000009fbd0fcef| 1Be2uQTHQC5V9QPTqSkHvGNpFA5H 00000000000000000000000000000000000000000000000000000009e2b117d2| 1Be2nTuUQDYvYgyHPfE6S4hBTVNc 00000000000000000000000000000000000000000000000000000009eb119a5e| 1Be2ncy8U6oS9UzUGQU13CW7prqo 00000000000000000000000000000000000000000000000000000009f371a027| 1Be2tHcpUiDPVcqdvu2v2KmtA1m9 00000000000000000000000000000000000000000000000000000009e6e1b74a| 1Be22Wi2usp5z2J1wRvfovS8pD7R 00000000000000000000000000000000000000000000000000000009fbd1be53| 1Be2eU7ktk7abQsFRHgVP1qmmpZW 00000000000000000000000000000000000000000000000000000009f371d249| 1Be2zLYgYPdSjL9cog8kCsWUVjax 00000000000000000000000000000000000000000000000000000009f7a1e133| 1Be2xv3Q6XtLnBAz4SmbqbaSkhs8 00000000000000000000000000000000000000000000000000000009de820a7c| 1Be2UF9NLfyLFbtm3TCbmuocc9N1 00000000000000000000000000000000000000000000000000000009e2b20b15|

--------------------------------------------------------------------------------
KEY FOUND! 2024-05-26 02:29:44.164813 +07:00
private key (WIF): KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9Mg1Upu7eJAtiDr
private key (hex): 00000000000000000000000000000000000000000000000000000009de820a7c
public key: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
address: 1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1
--------------------------------------------------------------------------------
Search completed

it's like 3 minutes for search by address.

look at this, example of use.

34 2^33...2^34-1 200000000...3ffffffff | x : 29 y: 34 - > > 0x330000000 < [ 0x330000000:0x3ffffffff ] [found on 0x34a65911d ]

38 2^37...2^38-1 2000000000...3fffffffff | x : 33 y: 38 - > > 0x2100000000 < [0x2100000000:0x2ffffffffff] [found on 0x22382facd0 ]

.. etc
i make this premature codes for saving more times with lowkey cpu speed for search, but work until 79 bit, rest of that, the output result for keyspace is not correct.
sorry i cant provide the real codes, because someone can brute that easily with his huge mining GPU farm

Tepan

jr. member

Activity: 77

Merit: 1

hi guys! who can help me to develop rust coding language?! (don't judge my statement and result, since i just new for learning this puzzle and trying new stuff)

i run this like 4-5 hours straight, i use pool keyspace and multi thread, the search only use CPU, let's find out can develop it with GPU power.

it's sequential and not random.

the thread is dividing key ranges and make the 1,5 bytes changed from left padding following how many thread are used.

Puzzle search
Script started at: 2024-05-25 20:56:03.700485 +07:00
from:0x23000000000000000 to:0x3ffffffffffffffff
target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

0000000000000000000000000000000000000000000000035200000002cc179e| 13zbaq4dADzLenZB6VdSdmAaqV8TABkHEf

average current speed is 15.000 Key/sec for each thread.

with some GPU power, i think my codes (?) can solve that in couple months.
my codes still make some bug, the address display is misleading the corresponding of private key, but it's still same prefix.
all of that still can search the matched, but the displaying of progress is not correct.
🙏🏻

example of pre-run.

000000000000000000000000000000000000000000000003c600000000002b0f | 13zbpbczKXAcx9q4NvTuEa5szGu3 000000000000000000000000000000000000000000000003520000000000a039 | 13zbNacfa9Nrz8YttQbzLVqT7y4w 000000000000000000000000000000000000000000000003c60000000000d456 | 13zbFwGk1JussoSK3gax39256VBu 000000000000000000000000000000000000000000000002de000000000103a3 | 13zbt3NfsVUjJu8FQWxFfxdePAFP 0000000000000000000000000000000000000000000000026a00000000010bd3 | 13zbix1E22g4FRk5hUcoMV1Hhvpd 000000000000000000000000000000000000000000000002de0000000001333e | 13zbDQnUKS1N8AqmynykC1QYNgwc 000000000000000000000000000000000000000000000002de00000000013e02 | 13zb7xLuqjuPKdbGt7rshDEjdprK 00000000000000000000000000000000000000000000000352000000000168ae | 13zbm8dR61ur1GqnQEmjrRsM5knP 000000000000000000000000000000000000000000000002300000000001923c | 13zbpdWGSwZpHK2zyR2o5XqgfXdv 0000000000000000000000000000000000000000000000026a0000000001c928 | 13zbp7u1bEeK94RCMtsvuNtqBrYo 0000000000000000000000000000000000000000000000038c0000000001e94a | 13zb56DAy494Drdngk2YchYRNfvF 0000000000000000000000000000000000000000000000023000000000023728 | 13zbFaEpeoY7Hrx6sTLdM3ZvvUW5 0000000000000000000000000000000000000000000000031800000000023ade | 13zbtT9na4bJdYoexnZ6YSt6KDHp

Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 86. (Read 230098 times)