Bitcoin puzzle transaction ~32 BTC prize to who solves it

[alek76]

Optimized code a little.
https://github.com/alek76-2/VanitySearch/blob/main/mod/other_files/GPUHash_nc_optimized.h
Previously, the data array was transferred from one function to another when initializing RIPEMD160.
I put the constants directly into the RIPEMD160Transform() function.
Now the question is, can this be optimized using compiler options? The uint32_t * array is no longer used.

Code:

__device__ void RIPEMD160Transform(uint32_t s[5],uint32_t* w) {

  uint32_t u;
  //uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4];
  //uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1;
  
  uint32_t a1 = 0x67452301ul, b1 = 0xEFCDAB89ul, c1 = 0x98BADCFEul, d1 = 0x10325476ul, e1 = 0xC3D2E1F0ul;
  uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1;

  //uint32_t t = s[0];
  //s[0] = s[1] + c1 + d2;
  //s[1] = s[2] + d1 + e2;
  //s[2] = s[3] + e1 + a2;
  //s[3] = s[4] + a1 + b2;
  //s[4] = t + b1 + c2;
  
  //uint32_t t = 0x67452301ul;
  s[0] = 0xEFCDAB89ul + c1 + d2;
  s[1] = 0x98BADCFEul + d1 + e2;
  s[2] = 0x10325476ul + e1 + a2;
  s[3] = 0xC3D2E1F0ul + a1 + b2;
  s[4] = 0x67452301ul + b1 + c2;//s[4] = t + b1 + c2;

Or will the compiler do it itself now? Who can test the speed and correctness of the code?
I checked it on Tesla T4, this code works.

[mcdouglasx]

I think that if the creator was to come here and give us hints, this would defeat the purpose of his creation which is to measure our cracking capabilities.

Can't really be giving out hints in an experiment like this one, we must check our own leads and see what comes out of it.

He succeeded in his idea. He showed our cracking capabilities  are poor.

Prize: 988.498 BTC (total), 31.998 BTC (won), 956.5 BTC (remaining)

His 956 BTC is relatively safe even the whole world knows the ranges where the private keys are.

I sometimes think that the creator has been withdrawing the BTC from the undisclosed wallets in recent years, I see no reason why someone who unlocks the puzzle should not share their keys anonymously once the wallet is emptied, either that or there is a possible sequence that we are not seeing.

[CY4NiDE]

He succeeded in his idea. He showed our cracking capabilities  are poor.

Prize: 988.498 BTC (total), 31.998 BTC (won), 956.5 BTC (remaining)

His 956 BTC is relatively safe even the whole world knows the ranges where the private keys are.

Yeah, for now it seems like the progress is halted, but as tech gets better this challenge will always provide a way of seeing where our capabilities are capping.

I sometimes think that the creator has been withdrawing the BTC from the undisclosed wallets in recent years, I see no reason why someone who unlocks the puzzle should not share their keys anonymously once the wallet is emptied, either that or there is a possible sequence that we are not seeing.

I feel like the people cracking these are keeping the keys for themselves 'cause the creator might send more funds to those wallets one day, as this already happened before.

Didn't #125 have like 1.25 BTC the day it was opened, and later on it got +11 BTC sent to it?

That would be a pretty good reason to keep these keys close to your chest.

[mcdouglasx]

I feel like the people cracking these are keeping the keys for themselves 'cause the creator might send more funds to those wallets one day, as this already happened before.

Didn't #125 have like 1.25 BTC the day it was opened, and later on it got +11 BTC sent to it?

That would be a pretty good reason to keep these keys close to your chest.

Because 125 had not been deciphered at that time, as you will see, 120 did not receive anything else.

[FlleOWA]

I think that if the creator was to come here and give us hints, this would defeat the purpose of his creation which is to measure our cracking capabilities.

Can't really be giving out hints in an experiment like this one, we must check our own leads and see what comes out of it.

He succeeded in his idea. He showed our cracking capabilities  are poor.

Prize: 988.498 BTC (total), 31.998 BTC (won), 956.5 BTC (remaining)

His 956 BTC is relatively safe even the whole world knows the ranges where the private keys are.

I sometimes think that the creator has been withdrawing the BTC from the undisclosed wallets in recent years, I see no reason why someone who unlocks the puzzle should not share their keys anonymously once the wallet is emptied, either that or there is a possible sequence that we are not seeing.

Behind the creation of this puzzle is a 100% mathematician scientist. And it was not created to test the security of Bitcoin. But for your own purposes. 1000 coins is the minimum deposit to get more. As a rule, there is no point in testing brute force and this is understandable. But it makes sense to look for vulnerabilities in the curve. And even a person without education can stumble upon a vulnerability and not understand what it is, but write about it in the topic. And the creator, for example, will be able to understand what to do with it and calmly gain access to wallets with a huge balance, recouping their costs.

[FlleOWA]

So are you accusing the puzzle creator of theft? Meaning he will later empty other people's wallets?

Here is another embarrassment for all the so called educated people, my post above, if you can, go ahead and solve it. 😂

Not necessary. He can then empty dead wallets from which there will be no demand. And as far as we know, there are a lot of lost wallets, especially wallets that did not have outgoing transactions after 2012. And this will not be theft, since even the real owner will not be able to confirm his right to this wallet. And you can easily, having a private key, say that it was yours, you just recently managed to find the key.

We all know that there is no system created by people that does not have vulnerabilities. Everything breaks. And Bitcoin too. It may even already be hacked, just why talk about it, withdraw your money and live happily.
Every year billions are stolen from the Visa and Maestro systems, but they don’t talk about it so you don’t panic. Even the Apple system is not secure as advertised.

Just if I could find a vulnerability that allows me to get any private key. I would quietly and calmly rummage through dead small wallets and cash out through exchangers. Why would I leak such information and put my life in danger? Such news will reset the price and many will simply lose billions, and many will want to take revenge on me for this.

[FlleOWA]

So are you accusing the puzzle creator of theft? Meaning he will later empty other people's wallets?

Here is another embarrassment for all the so called educated people, my post above, if you can, go ahead and solve it. 😂

Because it would be better than having a selected group to have access to the whole thing, imagine if someone had a backdoor to Bitcoin, do you know what they could do to anyone with huge stakes?

So which scenario is better? To have access to all the coins secretly and doing whatever you want, or forcing the whole system to change algorithms to stop any unauthorized access?
Not to mention, there is no such a thing as "lost" Bitcoins, because once you lose access to your keys, there is no possible way to prove that you have lost the access to your keys, therefore, any perceived lost coins, could still have owners with access to the keys, they just are not interested to reveal it. Regardless, even if they are truly lost, they are not yours to take. Period.

Well, this is all clear))

I have this question for you.
Let's say I found a key that I use as point G.
Using this, I add 1 to my search key, and I also subtract 1 to my search key. As a result, I get the same public key, one is 03 and the other is 02.

Is it possible in this case to calculate the private key I am looking for?

As far as I remember, by changing point G, as a result, we no longer add and subtract, but divide and multiply our public key? Or I was mistaken. Just knowing this, it seems to me that you can calculate the difference.

[mabdlmonem]

I have found a few interesting hints regarding the puzzle 130, since I don't know the actual private key, I will just leave them here for the author to verify.
Are the following values related to the puzzle 130 in any way? Like being the last characters, first characters, the key being divisible by them etc?
3c8
f2
ec

If yes then I might be onto something. Then I'd need a hint to follow up on it, you might also want to check the inverse key as well.

I think that if the creator was to come here and give us hints, this would defeat the purpose of his creation which is to measure our cracking capabilities.

Can't really be giving out hints in an experiment like this one, we must check our own leads and see what comes out of it.

The beginning of private key  for 130 is 0x3

[alek76]

The beginning of private key  for 130 is 0x3

You are already stuck with your guesses! Stop spreading spam!

Added mod 013

https://github.com/alek76-2/VanitySearch/tree/main/mod/013

Added Path - m/0'/0'/66' For 32 BTC Puzzle

Use SSE2 instructions - default VanitySearch code / Disable SSE cmd: -nosse
Initial SEED extension to 64 bits
GPU Added rotation - #define NB_SPIN 16
Modification file GPUHash.h
The speed on the Tesla T4 GPU is 670.98 Mkeys/s
If Use GPU Rekey multiple by 1000

RUN CMD:

Code:

VanitySearch.exe -stop -nosse -verbose 1 -level 0 -t 1 -bits 66 -r 10 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

VanitySearch.exe -stop -t 0 -nosse -o Result.txt -verbose 1 -level 0 -gpu -r 500000000 -bits 66 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so 

Added play sound buzzer.wav in Windows version

p.s. The binaries assemble everything themselves.

[dextronomous]

Added mod 013

https://github.com/alek76-2/VanitySearch/tree/main/mod/013

Added Path - m/0'/0'/66' For 32 BTC Puzzle

Use SSE2 instructions - default VanitySearch code / Disable SSE cmd: -nosse
Initial SEED extension to 64 bits
GPU Added rotation - #define NB_SPIN 16
Modification file GPUHash.h
The speed on the Tesla T4 GPU is 670.98 Mkeys/s
If Use GPU Rekey multiple by 1000

RUN CMD:

Code:

VanitySearch.exe -stop -nosse -verbose 1 -level 0 -t 1 -bits 66 -r 10 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

VanitySearch.exe -stop -t 0 -nosse -o Result.txt -verbose 1 -level 0 -gpu -r 500000000 -bits 66 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so 

Added play sound buzzer.wav in Windows version

p.s. The binaries assemble everything themselves.

Bro thanks again, will test, but is it still present somewhere the bip39_english.h and Winm.lib

[alek76]

Bro thanks again, will test, but is it still present somewhere the bip39_english.h and Winm.lib

Added in VanitySearch.vcxproj <AdditionalDependencies> Winmm.lib;
Wordlist_en.h in folder 013 commented - not use.
Just uploaded bip39_english.h. Thank you. Forgot to copy
They differ only in the sizes of the rows, the array is the same here and there.

If the countdown starts from zero, then you can change keyIndex = 65;
Replace:

Code:

keyIndex = (uint32_t)TARGET_KEY_BITS;// BITS 66

To:

Code:

keyIndex = (uint32_t)TARGET_KEY_BITS - 1;// BITS 66

Or any:

Code:

keyIndex = 65;

it will be a patch - m/0'/0'/65'
But we still don’t know the patch.

[mabdlmonem]

The beginning of private key  for 130 is 0x3

You are already stuck with your guesses! Stop spreading spam!

Ok!

[FlleOWA]

By the way, I didn’t find any discussion of the public key, the owner of this puzzle, in the topic.

Do you mean to say this by chance?

024b0faa9624763002e963816b2f6774df0dedd770896a9511cb5c9d90f674ecda

It is clear that a letter is missing, but even such a combination is too much for an accident.

[PrivatePerson]

Added mod 013

https://github.com/alek76-2/VanitySearch/tree/main/mod/013

I can't figure out how to calculate the ccap=20 parameter?
I have an RTX 4050 Laptop.
Help please.

Code:

 ./deviceQuery
./deviceQuery Starting...

 CUDA Device Query (Runtime API) version (CUDART static linking)

Detected 1 CUDA Capable device(s)

Device 0: "NVIDIA GeForce RTX 4050 Laptop GPU"
  CUDA Driver Version / Runtime Version          12.3 / 12.3
  CUDA Capability Major/Minor version number:    8.9
  Total amount of global memory:                 6140 MBytes (6438780928 bytes)
  (020) Multiprocessors, (128) CUDA Cores/MP:    2560 CUDA Cores
  GPU Max Clock rate:                            2055 MHz (2.06 GHz)
  Memory Clock rate:                             8001 Mhz
  Memory Bus Width:                              96-bit
  L2 Cache Size:                                 25165824 bytes
  Maximum Texture Dimension Size (x,y,z)         1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
  Maximum Layered 1D Texture Size, (num) layers  1D=(32768), 2048 layers
  Maximum Layered 2D Texture Size, (num) layers  2D=(32768, 32768), 2048 layers
  Total amount of constant memory:               65536 bytes
  Total amount of shared memory per block:       49152 bytes
  Total shared memory per multiprocessor:        102400 bytes
  Total number of registers available per block: 65536
  Warp size:                                     32
  Maximum number of threads per multiprocessor:  1536
  Maximum number of threads per block:           1024
  Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
  Max dimension size of a grid size    (x,y,z): (2147483647, 65535, 65535)
  Maximum memory pitch:                          2147483647 bytes
  Texture alignment:                             512 bytes
  Concurrent copy and kernel execution:          Yes with 1 copy engine(s)
  Run time limit on kernels:                     Yes
  Integrated GPU sharing Host Memory:            No
  Support host page-locked memory mapping:       Yes
  Alignment requirement for Surfaces:            Yes
  Device has ECC support:                        Disabled
  Device supports Unified Addressing (UVA):      Yes
  Device supports Managed Memory:                Yes
  Device supports Compute Preemption:            Yes
  Supports Cooperative Kernel Launch:            Yes
  Supports MultiDevice Co-op Kernel Launch:      No
  Device PCI Domain ID / Bus ID / location ID:   0 / 1 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 12.3, CUDA Runtime Version = 12.3, NumDevs = 1
Result = PASS

[citb0in]

Added mod 013

https://github.com/alek76-2/VanitySearch/tree/main/mod/013

I can't figure out how to calculate the ccap=20 parameter?
I have an RTX 4050 Laptop.
Help please.

This is architecture "Ada Lovelace", you need 8.9 so use ccap=89 in your compiling task. In case you have no success try downgrading and use max CUDA 11.8. However I wish you best of luck and success.

citb0in

[alek76]

Added mod 013

https://github.com/alek76-2/VanitySearch/tree/main/mod/013

I can't figure out how to calculate the ccap=20 parameter?
I have an RTX 4050 Laptop.
Help please.

This is architecture "Ada Lovelace", you need 8.9 so use ccap=89 in your compiling task. In case you have no success try downgrading and use max CUDA 11.8. However I wish you best of luck and success.

citb0in

and edit GPUEngine.cu; 4 lines are commented out; they are not in version 10.2.
https://bitcointalk.org/index.php?topic=1306983.msg63128300#msg63128300

[Stanislav01]

Can you tell me if I'm calculating the range scan time correctly for the 130 puzzle?

Time = (End Range - Start Range) / (Speed * 60 * 60 * 24 * 365)

Start Range = 200000000000000000000000000000000 (hex); 680564733841876926926749214863536422912 (decimal)
End Range =   400000000000000000000000000000000 (hex); 1361129467683753853853498429727072845824 (decimal)
Speed = 100 Ekeys/s

Time = (1361129467683753853853498429727072845824 - 680564733841876926926749214863536422912) / (100000000000000000000*60*60*24*365) = 215 805 661 416 years

[Woz2000]

My math concurs.

Can you tell me if I'm calculating the range scan time correctly for the 130 puzzle?

Time = (End Range - Start Range) / (Speed * 60 * 60 * 24 * 365)

Start Range = 200000000000000000000000000000000 (hex); 680564733841876926926749214863536422912 (decimal)
End Range =   400000000000000000000000000000000 (hex); 1361129467683753853853498429727072845824 (decimal)
Speed = 100 Ekeys/s

Time = (1361129467683753853853498429727072845824 - 680564733841876926926749214863536422912) / (100000000000000000000*60*60*24*365) = 215 805 661 416 years

[nomachine]

215 805 661 416 years

Your calculation is correct. With 100 Ekeys/s would take an incredibly long time.

That is unbreakable even at that speed.

Speed needed for a 130 range scan time of 5 minutes is approximately
 

719,000,000 Ekeys/s.

[NAKAMOT0]

I can give you some clues for this problem and you can reflect on it...
       *Addresses are in order.
       *Addresses are not random.
       * Addresses always have PVK values ​​that differ by one PVK value.
       * There is a pattern.

    The key is to use the common factor within each address pair and its PVK value.

     A common factor between addresses 1 and 2 is that their PVK value is equal to 3.

     A common factor between addresses 3 and 4 is that their PVK value is equal to 7.

     A common factor between addresses 5 and 6 is that their PVK value is equal to 21.

     Etc...



      PVK values ​​are always in a mathematical progression (in this case, I don't like to use the word "sequence") that appears to be in a progression of prime numbers.


       * What is important is not the PVK values ​​but the mathematical relationship between the PVK values.
       *Addresses are in a progression of prime numbers.
       *The addresses are always in order.
       * There is always a relationship between the PVK value of the following addresses.


       *PVK values ​​do not always have to be prime numbers.
       * PVK addresses are always generated mathematically and never randomly.
       * Don't look for the answer in the Bitcoin blockchain.

      * Think of the relationship between the directions as the common factor between two very large prime numbers.
       * The equation to be solved for the PVK values ​​is a unique mathematical solution.
       *Also remember that PVK addresses are always in order.

       *The key is the PVK value pattern.
       * The pattern goes beyond PVK values.


       * Use a mathematical relationship between the PVK values ​​to calculate the PVK values ​​of the directions in the depressed progressions.

    Some clues are a little more ambiguous, but if you think about it it can give you a little idea of ​​how to decipher the directions in this case.  I can't give you more information about the exact formula behind all this for security reasons, but I hope you have fun and someone very special sends you greetings.  ✌️