Solving ECDLP with Kangaroos: Part 1 + 2 + RCKangaroo

[RetiredCoder]

That's great and all, but I'm not sure your estimations fit the context of what you've quoted.

I'm well aware that there are a lot of optimizations for scalar multiplication, and it's great you have really fast code to do it in CUDA as fast as you state (which sounds miraculous in itself to be honest), but there's one thing you maybe missed: the private keys are not random, they're fed as input. Yeah, maybe redo the math after crawling private keys from GPU memory

Not sure why you had to bring smth from page 520 of that topic here though. It'd be much more interesting if you instead update us on 135 progress

Yeah may be I missed some context, I did not check carefully. But anyway, reading 0.5GK/s privkeys is only 16GB/s which is almost nothing for 4090 bandwidth.
I don't read "blah-blah" thread (it's disgusting), but sometimes when I'm bored I read your messages because you have some skills

[kTimesG]

That's great and all, but I'm not sure your estimations fit the context of what you've quoted.

I'm well aware that there are a lot of optimizations for scalar multiplication, and it's great you have really fast code to do it in CUDA as fast as you state (which sounds miraculous in itself to be honest), but there's one thing you maybe missed: the private keys are not random, they're fed as input. Yeah, maybe redo the math after crawling private keys from GPU memory

Not sure why you had to bring smth from page 520 of that topic here though. It'd be much more interesting if you instead update us on 135 progress

Yeah may be I missed some context, I did not check carefully. But anyway, reading 0.5GK/s privkeys is only 16GB/s which is almost nothing for 4090 bandwidth.
I don't read "blah-blah" thread (it's disgusting), but sometimes when I'm bored I read your messages because you have some skills

You also need to write 16 GB/s as well, since it's not a one-shot job. And there goes the 4090 max memory throughput.

So to compute even those minimum 250 MK/s, the first wall to pass is reading a file from disk at least at 8 GB/s, before even talking about GPUs and their memory bandwidth.

[RetiredCoder]

You also need to write 16 GB/s as well, since it's not a one-shot job. And there goes the 4090 max memory throughput.
So to compute even those minimum 250 MK/s, the first wall to pass is reading a file from disk at least at 8 GB/s, before even talking about GPUs and their memory bandwidth.

Following this logic, you forgot to mention time required to write the list to the disk before reading, also time to prepare that list before writing to the disk 
Well, ok, I just wanted to mention that there are some ways to calc random privkeys-to-pubkeys very quickly on GPU. Just a hint for those who are interested.

[clashroyalegrp]

You also need to write 16 GB/s as well, since it's not a one-shot job. And there goes the 4090 max memory throughput.
So to compute even those minimum 250 MK/s, the first wall to pass is reading a file from disk at least at 8 GB/s, before even talking about GPUs and their memory bandwidth.

Following this logic, you forgot to mention time required to write the list to the disk before reading, also time to prepare that list before writing to the disk 
Well, ok, I just wanted to mention that there are some ways to calc random privkeys-to-pubkeys very quickly on GPU. Just a hint for those who are interested.

Where i can get the RCKangaro exe for GPU search

[mjojo]

You also need to write 16 GB/s as well, since it's not a one-shot job. And there goes the 4090 max memory throughput.
So to compute even those minimum 250 MK/s, the first wall to pass is reading a file from disk at least at 8 GB/s, before even talking about GPUs and their memory bandwidth.

Following this logic, you forgot to mention time required to write the list to the disk before reading, also time to prepare that list before writing to the disk 
Well, ok, I just wanted to mention that there are some ways to calc random privkeys-to-pubkeys very quickly on GPU. Just a hint for those who are interested.

Where i can get the RCKangaro exe for GPU search

Many thanks to @WP
https://github.com/WanderingPhilosopher/RCKangaroo-Fork

[clashroyalegrp]

You also need to write 16 GB/s as well, since it's not a one-shot job. And there goes the 4090 max memory throughput.
So to compute even those minimum 250 MK/s, the first wall to pass is reading a file from disk at least at 8 GB/s, before even talking about GPUs and their memory bandwidth.

Following this logic, you forgot to mention time required to write the list to the disk before reading, also time to prepare that list before writing to the disk 
Well, ok, I just wanted to mention that there are some ways to calc random privkeys-to-pubkeys very quickly on GPU. Just a hint for those who are interested.

Where i can get the RCKangaro exe for GPU search

Many thanks to @WP
https://github.com/WanderingPhilosopher/RCKangaroo-Fork

Thankyou mate

[Cricktor]

Where i can get the RCKangaro exe for GPU search

How about you read the first page or a few more and have a look at the Github repo of RetiredCoder, it's basically there in the very first post (well, not directly, but it's no rocket science to use the link in the first post and look which repos Github user RetiredC offers, or am I missing something?

I mean, it's not directly hard to find, isn't it? https://github.com/RetiredC/RCKangaroo

[COBRAS]

Good afternoon


How many hours of GTX 4090 needs for solve puzzle 135 with SOTA ?

BR.

[hoanghuy2912]

Hello, I want to ask about RCKangaroo, how should I adjust the parameters to be standard for puzzle number 135 (I use 4060 mobile card, 16 gb ram but 8 gb is occupied by the operating system), thanks in advance

[HarryLeekGkG]

Hello RetiredCoder,

The DP takes too much RAM but if DP was set too high it will be difficult to get collision, is it possible for me through restarting program to generate different route everytime? in this case, I can set a low DP and don't need too much RAM to easily get some different DPs everytime.

Second, I would like to save partical tames when exit. and after too much DP saved, I would like to drop some old ones to get new ones. It's basically the same concept with the first one though.

Acturally I don't want to find the result after K > 1 or even more, I like K < 0.00001, which is almost nonsense I know.

[filo1992]

Hello,

keeping the same value of DP, the same range, is it possible to make a union of the tames files?

the program, when the tames file is created, continues to save the data even when it is looking for a public key?

[damiankopacz87]

Hello,

May I ask someone, who already has tames96.dat - tames100.dat, for sharing? If needed I will create tames by myself, but why to invent circle again if its already done?
I won't take #135, promise I need Thema for another purpose.

BR
Damian

[Nuclearkeys]

HELLO RETIRED CODER,

I WAS ENQUIRING HOW LONG IT TOOK YOU TO SOLVE PUZZLE #120 AND HOW MANY GPUs USED OR ANY DETAILS WILL BE OF GREAT HELP.

Thanks for your great code.

[Cricktor]

~~~

How about you learn to use a search engine (e.g. ninjastic.space) or even read a bit in this thread?

It took me barely a minute or two to find this post on the second page here:

Less than 37BTC, check you calculations.
Most of GPU code from RCKangaroo was used for #130.
I spent two months, about 400 RTX4090, I was lucky and solved it twice faster than expected.

[Nuclearkeys]

Thank you for pointing it out.

[bisovskiy]

Hello,

I am facing an issue when trying to calculate the private key at the collision of two checkpoint types. Specifically, I am working with the following pair:

Code:

82B0FB9D086D11223F7FD179 69267708D563F46CEEFFFFFFFFFFFFFFFFFFFFFFFFFF TYPE:0
82B0FB9D086D11223F7FD179 EE651EB9551FDBC41800000000000000000000000000 TYPE:2

For other combinations of types, I am able to successfully recover the private key. However, with this particular pair (TYPE:0 and TYPE:2), I am unable to find or compute the private key correctly.

Could anyone point out where I might be making a mistake? Are there any specific details or differences in the calculation logic when a collision involves TYPE:0 and TYPE:2 checkpoints? Any advice or suggestions on how to troubleshoot this would be greatly appreciated.

Thank you.

[kTimesG]

Hello,

I am facing an issue when trying to calculate the private key at the collision of two checkpoint types. Specifically, I am working with the following pair:

Code:

82B0FB9D086D11223F7FD179 69267708D563F46CEEFFFFFFFFFFFFFFFFFFFFFFFFFF TYPE:0
82B0FB9D086D11223F7FD179 EE651EB9551FDBC41800000000000000000000000000 TYPE:2

For other combinations of types, I am able to successfully recover the private key. However, with this particular pair (TYPE:0 and TYPE:2), I am unable to find or compute the private key correctly.

Could anyone point out where I might be making a mistake? Are there any specific details or differences in the calculation logic when a collision involves TYPE:0 and TYPE:2 checkpoints? Any advice or suggestions on how to troubleshoot this would be greatly appreciated.

Thank you.

Unless it's a bug, in some cases a collision can't solve the private key.

Example: Q is the target point.

Wild1 DP at Q + delta*G = {x, y}
Wild2 DP at -Q - delta*G = {x, -y}

The delta is identical in absolute size, so Q's scalar can't be solved, as all possible points satisfy such an equation.

[bisovskiy]

@RetiredCoder
Hello!
I really appreciate your work and would be grateful if you could clarify a few technical points. I’m sure your insights will be helpful for everyone interested in optimizing this method.

Could you please describe the behavior of the points in the algorithm? Do they always move in one direction, or are there situations where they move towards each other? If they do move towards each other, doesn’t this create a large number of small cycles? Why is the option where points move strictly in one direction until reaching the distance, and then start the path again, not used?

Why, with a smaller DP parameter on the same range, does a collision occur faster, while with a larger DP value, checkpoints are fixed approximately once per second but the collision may take minutes to occur?

How does the DP value affect the probability of a collision? If DP is simply the interval at which collision checks are performed.

Thank you in advance for your explanation, and I look forward to any details you can share!