R.x == d.x |if R.x equal to Publickey x we can solve

[same2026]

k*G=r.x  == d*G=d.x

My English littlebit, but I was told my concept.

if R equal to Publickey x  we can solve

this is example only
R                   = 0x7362f4d6ce57b70f0fc9781dbc92010f709ea60bee3b43bdfd763e860d6eff2f
S                   = 0xbb5739e3279db95257555a571a8a8c1cb36be86c1423b92a46137afa0600fceb
Z                   = 0x119c63b888b501a28c1e3902b65a8499a7d1bddcbc14120906c1e00a64f7ada5
Publickey    = 0x7362f4d6ce57b70f0fc9781dbc92010f709ea60bee3b43bdfd763e860d6eff2f, f1f4569c03bc6c0defa5a84b8ebe26a433504a0847b971aa55c8071b7f36ba18


i can prove if R.x==Publickey.x .if any one share one valid R,S,Z  i send Private-key  challenge me

same_must = 0x12345  # change your key 2**256 or any range
nonce = same_must
d          = same_must
z          = random(2**256)

send me R,S,Z , then i was crack then send
#2nd
Does anyone know of this type of puzzle case? If you do, please share the TXID or address here

[ercewubam]

It can be trivially solved:

Code:

s=(z+rd)/k
d=k
s=(z+rk)/k
s=(z/k)+r
s-r=z/k
(s-r)/z=1/k
k=z/(s-r)

Which means, that if you have z-value, r-value, and s-value, then you can calculate just "z/(s-r)", and recover the private key in this way. It is unlikely, that there are any such transactions in the wild, because anyone could easily sweep these coins.

[NotATether]

See this post:

There is an industrial way to run the lattice attack at scale and it's https://github.com/bitlogik/lattice-attack .

It requires that you know at least 4 bits of each nonce, with MSB and LSB being preferred as it simplifies things.

You also need at least 88 signatures. If you have more bits, you'll need less.

There are several solvers with increasingly long runtime and more accurate results, such as LLL, BKZ-15 BKZ-25, BKZ-35, etc

You must understand however, that even with a large signature set, finding a solution is not guaranteed. Because increasing the number of dimensions in the lattice via adding more signatures merely makes the problem space bigger, and it is possible that the algorithm fails to find a solution, similar to a given linear algebra system.