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

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

---

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.

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.

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 

Constants in GPU code - Get 64bits lsb negative inverse of SecpK1 order
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.

This may be useful to you 

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.

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)  

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.😉

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."

---

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.

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?

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.

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.

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


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.

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.

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.

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?

---

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.

if (px[g][0] % DPmod == 0) { //   If you mean this?

1. I think that this is precisely the correct meaning. Yes, I tried using a mask (bitwise & operation) - it doesn't provide much of a speed benefit. Another mask is inverted and the "&" operation can add unnecessary points to the table. DP must be selected modulo!!!
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.
That's all. And on the server there is a comparator that also runs on a timer.
It seems like I've already told you a lot. Write the code - add it.
I can tell you a secret that errors appear after several hours of work not because of the bit operation "%". They appear due to arbitrary data that initially hangs in the most significant bits. bits64[4] is more than 256 bits of data. Before putting data into the GPU, you need to check it. Declaring an Int while simultaneously assigning a value from another Int variable does not clear the high-order bits. This is the second time I’ve repeated myself and repeated myself. Int is first declared and then assigned a value. The .Set() operation does not clear the high-order bits.
The SetInt32() and Rand() function clears. I say analyze the code. Even I, 3 years ago, did not have such care in the code. Everything should be fine now 
This could be your errors in the GPU or due to data overflow. No need to overload the GPU. Set GRP SIZE 64. The physical memory may also be bad - the memory chip itself ( or 1 of 8 ) . And so everything should be clean.

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

---

Edit: people will love you when you play dumb, you see how their tone changed after I asked a stupid question?

I am still learning to code for GPU, guys it is not so easy as you think.


No big mistery of that:

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

Alek, as someone who is extremely familiar with your program, and have modified it over the years, it is a lot slower than JLPs, but it has certain benefits that I like, such as saving points to a text file.

Possible ways to speed up your code; drop the modulo function to check for DPs and just use a mask like JLPs code. That may provide a speed up and also cause less erroneous points; these erroneous points happen a lot once the GPU has ran for hours.

I’ll have to look at your updated code sometime in the near future to see all of your changes.

But your Kangaroo GPU was the first & a trendsetter!

This isn’t your topic; you did not start this topic so maybe keep all of your confusing, showing nothing, posts on a topic you did start. That sounds fair.

Hopefully no one takes what you say so seriously, I mostly laugh when you talk about expert, published studies, etc., as you joking, being facetious.

But to any newbie trying to learn or figure something out, your posts on div sub add, do you see it, are really not helping anyone. You give no concrete examples to what you’re doing and what you found out. Those are the posts that do not help this topic’s members.