Bitcoin puzzle transaction ~32 BTC prize to who solves it

[WanderingPhilospher]

No big mistery of that:

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

Ok, do you know how we can shift the place of bolded part? To make it look like this:


EBAAEDCE6AF48A03BBFD25E8CD0364141FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

Or even better, imagine this is target :

0x0000000000000000000000000000000000000000000000000000000001234567

Now how can we make it look like this:

FFFFFFFFFFFFFFFFFFFFFFFF1234567EBAAEDCE6AF48A03BBFD25E8CD0364141

Lol, this is simple add or sub, to change all of those.

But for the last one, why would you take a smaller target and make it astronomically bigger?

DP must be selected modulo!!!

Why do you say this is a must?
DP with a mask works just as well and it doesn’t require an additional math step.

I agree, writing to files does slow it down; going from DP 20 and below to a DP above 24 is a drastic speed difference.

But even with a DP of 0, for JLPs, there is no speed drop. So maybe your rewrite to a table is best.

With that said, I prefer a hash table to store and text files to compare; this makes it easier when trying to compare files for a collision versus trying to merge large hash table files (because now you need better resources with higher RAM) whereas comparing text files, you can get away with 4GB RAM. Maybe you are creating something new with the best of both worlds.

[1715309585]

1715309585

[alek76]

Why do you say this is a must?
DP with a mask works just as well and it doesn’t require an additional math step.

Because I previously read an article where Pollard's selected highlighted points with zeros at the end.
And using a DP less than 16-18 will naturally slow down the speed.

[WanderingPhilospher]

Why do you say this is a must?
DP with a mask works just as well and it doesn’t require an additional math step.

Because I previously read an article where Pollard's selected highlighted points with zeros at the end.
And using a DP less than 16-18 will naturally slow down the speed.

You can run a mask with trailing zeros. A DP mask is not only zeros at the beginning. A DP mask can be at beginning or end.

And yes, when writing to a file the lower DP slows down the program but when using JLPs/writing to a table, it doesn’t slow down the speed.

[nomachine]

Guys come on, seeing a few things like puzzle 66, sha256 double, base58 in your scripts is a turn off.🤣

For how long you are going to stick with finding addresses? I believe I have said this before, you don't need to go beyond rmd160 check, just generate public key, do a sha256 and a rmd160 then compare with rmd160 of puzzle, when you convert rmd160 to address, you are doing the following which is unnecessary : adding network byte + sha256d + taking checksum + adding checksum + encoding to base58. So 5 extra steps, 5 useless operations per key.

You can condense the code into a one-liner to calculate the RIPEMD-160 hash from a decimal private key as follows:

Code:

import sys, random, hashlib, ecdsa
while True:
    dec = random.randint(36893488147419103231, 73786976294838206463)
    h160 = hashlib.new('ripemd160', hashlib.sha256(ecdsa.SigningKey.from_string((b'\x00' * 32)[:-len(dec.to_bytes((dec.bit_length() + 7) // 8, 'big'))] + dec.to_bytes((dec.bit_length() + 7) // 8, 'big'), curve=ecdsa.SECP256k1).get_verifying_key().to_string("compressed")).digest()).digest()
    message = "\r{}".format(h160.hex());messages = [];messages.append(message);output = "\033[01;33m" + ''.join(messages) + "\r";sys.stdout.write(output);sys.stdout.flush()
    if h160.hex()=='20d45a6a762535700ce9e0b216e31994335db8a5':print(dec);break

But this means absolutely nothing in terms of shortening the task.

5, 50, 500, even 1000 Mkeys means nothing realistically.

We need much, much, much more speed

p.s.
I don't even think C++ is enough. We would have to invent a new programming language.

[mcdouglasx]

No big mistery of that:

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

Ok, do you know how we can shift the place of bolded part? To make it look like this:


EBAAEDCE6AF48A03BBFD25E8CD0364141FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

Or even better, imagine this is target :

0x0000000000000000000000000000000000000000000000000000000001234567

Now how can we make it look like this:

FFFFFFFFFFFFFFFFFFFFFFFF1234567EBAAEDCE6AF48A03BBFD25E8CD0364141

Lol, this is simple add or sub, to change all of those.

But for the last one, why would you take a smaller target and make it astronomically bigger?

 

One of the reasons why it might be better to add and multiply and increase the range of the keys is that ecc works like a clock. If you do an addition or multiplication that is around the end,you would automatically get a key that reflects a low range. .
Remember that there are two pairs of keys that are the same but represented in different ranges, one starts with 02 and the other with 03 in the case of compressed pubkeys.

[WanderingPhilospher]

One of the reasons why it might be better to add and multiply and increase the range of the keys is that ecc works like a clock. If you do an addition or multiplication that is around the end,you would automatically get a key that reflects a low range. .
Remember that there are two pairs of keys that are the same but represented in different ranges, one starts with 02 and the other with 03 in the case of compressed pubkeys.

I know how it works. Did you even look at his example that I was referring to?

Also, 160 bit (the highest of these puzzles) with a known range (as all of the challenge/puzzle bits) are what most are focusing on here. To add sub div or mult to go around the clock (without knowing 100%) is not smart. But if you can reduce the ranges, closer to 0 and with 1 key or very few keys, that’s where the money will be made.

[digaran]

you would automatically get a key that reflects a low range.

I swear I was starting to doubt my sanity, at least now I know I'm not totally insane.
Your understanding shows that you have worked with scalars and know what happens when you operate mod n.

Now have you tried to work with target and it's 1/16? Try divide & add/sub scalar.
One thing I noticed, even if you post a private key of a funded address, not all but some people would ask what is this, what should we do with it?😂
And say how is that going to help us solve a puzzle, while they think finding a way to partially break ECC is like planning for a family picnic or throwing a dice and get lucky to land on a key just like that.
To understand, you have to try any possibility until you find a solution, and since the group order is fixed, you can observe what happens when you divide different keys from different ranges, like sometimes you get 8 with some 0s after it, and when you divide by a larger number you'd get something like 67b with some trailing 0s, sometimes it goes like 8, c, 4, with trailing 0s.

You can understand what I say if you divide 0x1 by even or odd numbers, e.g, 2, 4, 6, 8 or 3, 5, 7 etc.

Something to work with:
Target: 1001, sub 200 to get 801, now if you divide 801 and 1001 by 200 you get 1, but do it using scalar, and set your range to 2:400, you will see 256 bit keys and in the middle only "1". Now how can we find an unknown key close to 200? And start by dividing and sub to land on one of the unknown key's divisor.

Let me explain, think of target as 1600, now if you divide and sub 1000 and 600, you'd get 400 being divided, now what if you work with 600 and 400, you'd get 200 divided, now imagine all the keys above are odd, how can we work with them by subtraction/addition only to get a composite number?

[mcdouglasx]

One of the reasons why it might be better to add and multiply and increase the range of the keys is that ecc works like a clock. If you do an addition or multiplication that is around the end,you would automatically get a key that reflects a low range. .
Remember that there are two pairs of keys that are the same but represented in different ranges, one starts with 02 and the other with 03 in the case of compressed pubkeys.

I know how it works. Did you even look at his example that I was referring to?

Also, 160 bit (the highest of these puzzles) with a known range (as all of the challenge/puzzle bits) are what most are focusing on here. To add sub div or mult to go around the clock (without knowing 100%) is not smart. But if you can reduce the ranges, closer to 0 and with 1 key or very few keys, that’s where the money will be made.

I'm sorry, it has nothing to do with the example, I just point out that it is a better idea to add and multiply than to subtract and divide because the objective is unknown, with divisions or subtraction the probability of falling into negative or floating is immense, however by multiplying there will only be only one direction. therefore it is better to do random multiplications to the target, make a database and scan them (omitting 02 and 03) from 1-xxxxxxxxx (depending on your computing power, you choose how big the range is).
If the script does not find a match, it repeats in a loop creating another database.
If you find a match, "bingo."

you would automatically get a key that reflects a low range.

I swear I was starting to doubt my sanity, at least now I know I'm not totally insane.
Your understanding shows that you have worked with scalars and know what happens when you operate mod n.

Now have you tried to work with target and it's 1/16? Try divide & add/sub scalar.
One thing I noticed, even if you post a private key of a funded address, not all but some people would ask what is this, what should we do with it?😂
And say how is that going to help us solve a puzzle, while they think finding a way to partially break ECC is like planning for a family picnic or throwing a dice and get lucky to land on a key just like that.
To understand, you have to try any possibility until you find a solution, and since the group order is fixed, you can observe what happens when you divide different keys from different ranges, like sometimes you get 8 with some 0s after it, and when you divide by a larger number you'd get something like 67b with some trailing 0s, sometimes it goes like 8, c, 4, with trailing 0s.

You can understand what I say if you divide 0x1 by even or odd numbers, e.g, 2, 4, 6, 8 or 3, 5, 7 etc.

Something to work with:
Target: 1001, sub 200 to get 801, now if you divide 801 and 1001 by 200 you get 1, but do it using scalar, and set your range to 2:400, you will see 256 bit keys and in the middle only "1". Now how can we find an unknown key close to 200? And start by dividing and sub to land on one of the unknown key's divisor.

Let me explain, think of target as 1600, now if you divide and sub 1000 and 600, you'd get 400 being divided, now what if you work with 600 and 400, you'd get 200 divided, now imagine all the keys above are odd, how can we work with them by subtraction/addition only to get a composite number?

If you see that your idea makes sense, execute it and you will know if it is good or not, regardless of what the majority say, in the end we all ignore something.
Albert Einstein: he was not admitted to the university.
Marilyn vos Savant: questioned by mathematicians.
They are examples that the opinion of others does not matter.

[digaran]

Edited to remove some content. Oh and I found a way to make solving these puzzles much easier. Since no one is interested, I won't bother to post and talk about it.😉

[nomachine]

2. The only problem is the time it takes to open a large file to write one line. That's why everything was so slow. With a table, even just with an Int *var array, everything happens much faster. I accumulated 1024 points, opened the file and wrote it down, and so on in a circle. There you just need to add a counter and conditions, rewrite the File2save() function. But I have already rewritten it, which I advise you to do as well. I agree this will take some time. Github has not been updated.
After these changes, the speed increased.
3. The periods for preserving the working herd of kangaroos are set once every 10 minutes. Flags are set based on the timer, and based on the presence of flags, data from the GPU is uploaded to the array. Next, they are written from the array to the work file. Function SaveWorkKangaroosToFile(). And when the program is restarted, on the contrary, the start keys are not generated, but are unloaded from the file. Function LoadWorkKangaroosFromFile().
4. Text files provide an advantage, since you do not need to process a large table with data every time. The table is cleared - this is also time. And the array can simply be rewritten. There is a difference? I saved a small file and spat it out to the server via a socket.

I already tried all these steps. Some physical maximum is around 600 Mkeys - if you manage to hack the CUDA kernel (+GPU BIOS modding) we will probably reach 1000-1200 Mkeys as stated by the Philosopher.

I think more and more that we need a very fast (predefined?) database(via unix socket) - instead of text files.

Has anyone tried to make Kangaroo in PHP?  

Just thoughts from my notes:
Create a MySQL database that will store the data for the tame and wild herds.
Create tables to store the data, with appropriate fields such as 'x' and 'y' for points.
Create a PHP script that connects to the MySQL database and performs the required operations.
Use PHP's mysqli or PDO to establish a connection to your MySQL database.
Create a PHP class similar to the 'Point' class in the code to represent points on the elliptic curve.
Translate the mathematical functions egcd, rev, mul2, add, mulk, X2Y*(or whatever you call them), and check into PHP.
Replace specific libraries or functions with their PHP equivalents.
Modify the file reading/writing functions to interact with your MySQL database.
Replace file I/O operations with database query and update operations.
Use PHP's rand() or random_int() to generate random numbers.
Define the constants (modulo, order, Gx, Gy, etc.) in your PHP script.
Modify the output to store results or print information as needed. etc...
Share a Kangaroo MySQL database across the globe. (Peer-to-Peer)  

[alek76]

Has anyone tried to make Kangaroo in PHP?  
...
Share a Kangaroo MySQL database across the globe. (Peer-to-Peer)  

The number of manipulations does not increase the speed. It’s easier to make a converter from txt to sql. Let the PHP script look for a collision in the table. It’s even easier to make a list of text files and check them with a Python script. The simpler the faster, that's how it is.

[alek76]

Constants in GPU code - Get 64bits lsb negative inverse of SecpK1 order

Code:

print 'GET MM64 Mod P' 

invP = inverse_mod( -_p, (2**64))

MM64 = hex(invP)[2:-1]

MM64 = MM64.upper()

MM64 = '0x' + MM64 + 'ULL'

print MM64

print 'GET MM64_Order Mod N' 

invP = inverse_mod( -_r, (2**64))

MM64o = hex(invP)[2:-1]

MM64o = MM64o.upper()

MM64o = '0x' + MM64o + 'ULL'

print MM64o

f = open('MM64.txt', 'a')
f.write('\n'.join(['#define MM64 ' + MM64 + '\n' + '#define MM64o ' + MM64o + '\n' ]))
f.close()

Result:
#define MM64 0xD838091DD2253531ULL
#define MM64o 0x4B0DFF665588B13FULL

Once upon a time I added inversion modulo _N. It was not originally in the Int class. There you just need to change _P to _N. This is the Montgomery method. But you can also do it using the DRS62 method. Simply replace MM64 with MM64o and the inversion will be modulo _N (this Order).
This function is necessary for dividing the Public key.

Code:

// ------------------------------------------------
// add by alek76-2
void Int::ModInvOrder() {// Montgomery method

  // Compute modular inverse of this mop _N
  // 0 < this < _N  , _N must be odd
  // Return 0 if no inverse

  // 256bit 
  
  Int _N;
  _N.SetBase16("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
  
  Int u(&_N);
  Int v(this);
  Int r((int64_t)0);
  Int s((int64_t)1);
  
  //
  
  Int x;
  int k = 0;

  // Montgomery method
  while (v.IsStrictPositive()) {
    if (u.IsEven()) {
      shiftR(1, u.bits64);
      shiftL(1, s.bits64);
    } else if (v.IsEven()) {
      shiftR(1, v.bits64);
      shiftL(1, r.bits64);
    } else {
      x.Set(&u);
      x.Sub(&v);
      if (x.IsStrictPositive()) {
        shiftR(1, x.bits64);
        u.Set(&x);
        r.Add(&s);
        shiftL(1, s.bits64);
      } else {
        x.Neg();
        shiftR(1, x.bits64);
        v.Set(&x);
        s.Add(&r);
        shiftL(1, r.bits64);
      }
    }
    k++;
  }

  if (r.IsGreater(&_N))
    r.Sub(&_N);
  r.Neg();
  r.Add(&_N);

  for (int i = 0; i < k; i++) {
    if (r.IsEven()) {
      shiftR(1, r.bits64);
    } else {
      r.Add(&_N);
      shiftR(1, r.bits64);
    }
  }
  Set(&r);

}
// ------------------------------------------------

This may be useful to you 

[MoreForUs]

I will build out any script. Tell me your ideas and i will build. anyone interested PM.
you may have an idea that can lead to victory, may not be sure how to write the program. I've got you.
it may be taking forever because a great idea hasn't been built out yet 

[WanderingPhilospher]

Constants in GPU code - Get 64bits lsb negative inverse of SecpK1 order

Code:

print 'GET MM64 Mod P' 

invP = inverse_mod( -_p, (2**64))

MM64 = hex(invP)[2:-1]

MM64 = MM64.upper()

MM64 = '0x' + MM64 + 'ULL'

print MM64

print 'GET MM64_Order Mod N' 

invP = inverse_mod( -_r, (2**64))

MM64o = hex(invP)[2:-1]

MM64o = MM64o.upper()

MM64o = '0x' + MM64o + 'ULL'

print MM64o

f = open('MM64.txt', 'a')
f.write('\n'.join(['#define MM64 ' + MM64 + '\n' + '#define MM64o ' + MM64o + '\n' ]))
f.close()

Result:
#define MM64 0xD838091DD2253531ULL
#define MM64o 0x4B0DFF665588B13FULL

Once upon a time I added inversion modulo _N. It was not originally in the Int class. There you just need to change _P to _N. This is the Montgomery method. But you can also do it using the DRS62 method. Simply replace MM64 with MM64o and the inversion will be modulo _N (this Order).
This function is necessary for dividing the Public key.

Code:

// ------------------------------------------------
// add by alek76-2
void Int::ModInvOrder() {// Montgomery method

  // Compute modular inverse of this mop _N
  // 0 < this < _N  , _N must be odd
  // Return 0 if no inverse

  // 256bit 
  
  Int _N;
  _N.SetBase16("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
  
  Int u(&_N);
  Int v(this);
  Int r((int64_t)0);
  Int s((int64_t)1);
  
  //
  
  Int x;
  int k = 0;

  // Montgomery method
  while (v.IsStrictPositive()) {
    if (u.IsEven()) {
      shiftR(1, u.bits64);
      shiftL(1, s.bits64);
    } else if (v.IsEven()) {
      shiftR(1, v.bits64);
      shiftL(1, r.bits64);
    } else {
      x.Set(&u);
      x.Sub(&v);
      if (x.IsStrictPositive()) {
        shiftR(1, x.bits64);
        u.Set(&x);
        r.Add(&s);
        shiftL(1, s.bits64);
      } else {
        x.Neg();
        shiftR(1, x.bits64);
        v.Set(&x);
        s.Add(&r);
        shiftL(1, r.bits64);
      }
    }
    k++;
  }

  if (r.IsGreater(&_N))
    r.Sub(&_N);
  r.Neg();
  r.Add(&_N);

  for (int i = 0; i < k; i++) {
    if (r.IsEven()) {
      shiftR(1, r.bits64);
    } else {
      r.Add(&_N);
      shiftR(1, r.bits64);
    }
  }
  Set(&r);

}
// ------------------------------------------------

This may be useful to you 

How can or might this be useful? When it comes to Kangaroo method, I think people over think it. You just need to find as many leading or trailing 0s (or any other hex character) as fast as possible.
The tame or wild range should be 1 range and the other should be throughout the range.
Find leading or trailing DPs, fast, set tame higher than wilds. It should be that easy.

[alek76]

I will build out any script. Tell me your ideas and i will build. anyone interested PM.
you may have an idea that can lead to victory, may not be sure how to write the program. I've got you.
it may be taking forever because a great idea hasn't been built out yet  

If you can  , then write a script that will determine the parity of the public key  

How can or might this be useful? When it comes to Kangaroo method, I think people over think it. You just need to find as many leading or trailing 0s (or any other hex character) as fast as possible.
The tame or wild range should be 1 range and the other should be throughout the range.
Find leading or trailing DPs, fast, set tame higher than wilds. It should be that easy.

Yes. Useful for dividing PK. Invert several random keys modulo N, then multiply them by the target PK. And then you drive it into a kangaroo. I checked it works. Divide by no more than 2^11, otherwise the probability of kangaroo work will be low.
There may be several of them, all targets divided. But some goals are useless because the divisor is not suitable.

[lordfrs]

puzzle 130 private key is even number 

[alek76]

puzzle 130 private key is even number 

Well, tell me how you know this? 

[nomachine]

I will build out any script. Tell me your ideas and i will build. anyone interested PM.
you may have an idea that can lead to victory, may not be sure how to write the program. I've got you.
it may be taking forever because a great idea hasn't been built out yet 

Mnemonic code words for Puzzle 66 

[digaran]

I will build out any script. Tell me your ideas and i will build. anyone interested PM.
you may have an idea that can lead to victory, may not be sure how to write the program. I've got you.
it may be taking forever because a great idea hasn't been built out yet 

Go for it, we have 2 targets, we want to divide them both by a range, and then we want to add or subtract their results of division, but with a twist, if we are dividing for example by 2, 3, 4, 5, 6, we want to add or subtract target 1 divided by 6 from target 2 divided 5.  I have learned a few tricks and it can be done this way, it could result in something good.
If you could make it to work by both scalar and points it would be great, we could comment out scalar operations when we are working with points, and vice versa.
Another one:
Ters function, we want to have 2 targets performing ters on each of them by different values, example, if we had -1 divide by 2, now we want to have a different strategy with second target, like, target 2 be -2 divide by 3, and then we want to either add or sub the results. Both over scalar and points preferably. Thanks and good luck.

[nomachine]

Fundamentally, it is not a question of a desire/idea what someone conceived for building as script.
Ceate/invent a random generator 10 times faster than all existing ones. Any programming language.
Then we talk further on ideas.

There are very fast ones especially for short keys. But we need very large keys.