Bitcoin puzzle transaction ~32 BTC prize to who solves it

[alek76]

What 3rd key? Digaran ...please if you don't understand what I posted then ask...and nicely too for that matter. Just because our ideas and methods do not align does not mean yours is superior. And certainly put me in touch with the creator of the puzzle...I'll certainly tell him the first 4 digits of the private key of puzzle 130 for that 1 bitcoin and even gave a 110 bit range for it.

Puzzle 130 = first key. End range = second key. Their difference = third key. Maybe you should read your post again. Here is the deal, I will give you a public key, just tell me the first character of it's private key, you have 14 characters to choose from but only 1 correct guess. If you can't, then we'll have nothing to discuss on this subject.

Code:

022d410abfc76bc647c29819c3349c8a59c84af25feedf59b932643d10299660f0

Edit, I tried looking in my pockets, but couldn't find the creator of this puzzle, let me check the closet. Lol. If you want to get in touch, solve a puzzle, they will find you, don't worry about the time.😉

Can you explain the logic of the difference of a key by the end of the range etc? I cannot see any valid argument in this.

No one can do this. And Digaran won't be able to.
I will try to explain what the asymmetric encryption algorithm secp128k1 means. And why, you will never find the relationship by the beginning or ending bytes, between the private and public key. For example:
1. I wished for 2 factors and tell you the remainder of the modulo division.
Can someone tell me what numbers I multiplied? No he can’t!!!
If he can, it means he broke EC
2. This operation of multiplication and division modulo is performed 130 times in this case.
3. There is only linearity in modulo multiplication and division operations.
Well, let's start breaking the EC? I guessed two factors, the result of division modulo _P is equal to:

Code:

0x9478230a3fb794b615ac8f97768ab8feb86784804ef03de53ec26f8cbfbc37f5

Digaran please tell me the multipliers, I  2 multipliers. Or anyone.  

[nomachine]

Maybe this code. I don't know what else to think of

I sent you a PM what to look at....

[btc11235]

Ok, so, when I first found out about this puzzle and started looking into it earlier this year, I was initially working under the assumption that there would be some clues or patterns that could be found to help unlock the remaining wallets... But, of course, I now know what you all already knew: There are no clues or patterns, at least nothing included intentionally by the person who created and funded these wallets...

However, I recently revisited my pattern-finding script, looking instead for any bias(es) in the data that I might be able to find (created by the pseudo-random number generator, or by assumptions built into the wallet generator's code, etc) to at least help shrink the given search spaces as much as possible, and I think I may have (possibly, maybe) found one... The problem is that even if I'm right, I just don't have the computing power to test my theory, nor the funds to buy/rent it, and won't for the foreseeable future... So I'm just going to post it here, in the hopes that, if it is useful at all, then whoever uses this to help them open any of the remaining wallets will be generous enough to kick-back a percentage of the winnings (my BTC address is bc1qmzud9l4aedq6h73efaj3vg3fdqhgv8w4ktq0pt)

Ok, so, my theory goes like this: I initially looked at all of the known pkeys (as decimal numbers, not hex) and calculated their location within the given puzzle's search space as a percentage, like this for Puzzle #11:

Code:

Hex: 0000000000000000000000000000000000000000000000000000000000000483
Hex as Decimal: 1155
Search Space: 1024 to 2047
Percent: (1155 - 1024) / (2047 - 1024) = 12.8%

Now, if that math is wrong, then I'm already screwed and you can give-up now

But after doing that for all the known pkeys, and looking at all the results, I didn't see any pattern, so I gave up and moved on to the next possible pattern I could think of... However, when I went back looking for a bias in the data instead of an outright pattern, I believe I have found that certain percentages (when just looking at the whole number... so 12% for the above example, instead of 12.8%) do (seemingly) occur more often than most...

I first grouped them by the tens (so 20 for 20-29, and 30 for 30-39, etc) and here's the results:

Code:

Tens  Count  Percents
60    13     62,63,64,64,64,65,66,66,66,67,68,69,69
30    9      31,31,32,33,33,35,36,36,38
40    9      40,43,43,44,45,45,46,46,49
10    7      10,12,13,17,17,19,19
90    7      91,92,92,95,95,96,97
80    6      82,82,82,82,82,87
20    6      22,23,23,27,28,28
50    5      50,51,51,54,57
70    5      70,72,72,75,75
0     4      0,6,8,9

So, looking at it that way, you can see that it seems like the 60-69% range hits way more often than the average... But even searching 10% of any given search space is still a crap-ton of brute-forcing to do, so I kept looking and noticed that certain individual numbers show-up more often than others, so next I grouped more simply by just the whole number:

Code:

Count  Percents
5      82
3      64,66
2      17,19,23,28,31,33,36,43,45,46,51,69,72,75,92,95
1      0,6,8,9,10,12,13,22,27,32,35,38,40,44,49,50,54,57,62,63,65,67,68,70,87,91,96,97

And here it appears as though the 82% range occurs way more often than any other, followed closely by 64% and 66% (which occur 3 times each)... Which could (again, theoretically) let you search only 1-3% of any given search space... But, unfortunately, that's still way too much brute-forcing for me to even attempt, given that there's no way to know which of the remaining pkeys will hit these ranges (and so you'd have to try several before finding a hit...)

...and that's assuming that this is a true bias in the data, and not just a coincidence that would even-out over time, which is the other possible way I can think of that this theory could completely fail: Maybe all the keys that could be found within the eighty-two-point-something percent range of their search space (for example) have already been found, leaving the others that have only hit once or twice so far to "catch up", statistically speaking...

Anyway, am I just an idiot, or does this make any sense to y'all...?

[Kamoheapohea]

Please stop. Search help. This thread became less usefull since you've entered it. Your base conversions and maths are stupid. Nobody wil ever benefit of your "works". Thank you.

[digaran]

Please stop. Search help. This thread became less usefull since you've entered it. Your base conversions and maths are stupid. Nobody wil ever benefit of your "works". Thank you.

Code:

     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣴⣾⣿⣿⣿⣿⡿⠿⠿⠛⠻⠿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⣿⣿⣿⡿⠟⠋⠁⠀⠀⠀⠀⠀⠀⠀⠙⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⠟⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣻⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⣿⣿⣿⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⠟⠉⠉⢳⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⣿⣿⣷⠀⠀⠀⠀⠀⣠⡴⠶⠦⡄⠀⠀⠈⠃⡴⢻⣷⣾⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣆⠀⠀⠀⠞⠁⢀⣴⣶⠦⡄⠐⡆⠸⣟⠚⠋⠁⠈⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⢯⣸⣿⠟⠃⠀⢷⠀⠈⠣⠀⠀⠀⠈⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠟⠀⠀⠀⢨⡷⣄⠀⢿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣿⣿⣿⣿⡟⠛⠿⢿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠐⠛⠀⠀⠀⠙⠆⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⡹⣄⡶⠀⠀⠀⠀⠀⠀⠀⠀⢀⣦⠀⠀⠀⣀⡤⠴⣶⠀⠀⢸⣦⣤⣄⣀⡀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⢀⣀⣀⣤⣽⣿⣿⣧⡻⣷⣦⣀⡀⠀⠀⠀⠀⠀⠈⠙⠂⢶⣯⣥⣴⣾⠏⠀⠀⣼⣿⣿⣿⣿⣿⣿⣷⣦⣤⣀
⠀⠀⢀⣠⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣤⡰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠁⠀⠀⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
⣴⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡄⠀⠘⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠴⠆⠀⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⠳⣄⠀⠉⠓⠶⠄⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
⠙⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠀⠈⠓⠀⠀⠀⠀⠀⠀⠈⠓⠒⠒⠚⠙⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛ 

[alek76]

Please stop. Search help. This thread became less usefull since you've entered it. Your base conversions and maths are stupid. Nobody wil ever benefit of your "works". Thank you.

It looks like a flood and an advertisement for a mixer.
I don't comment on his posts. Im added user digaran to ignore list. My patience has run out

[citb0in]

Ok, so, when I first found out about this puzzle and started looking into it earlier this year, I was initially working under the assumption that there would be some clues or patterns that could be found to help unlock the remaining wallets...

But, of course, I now know what you all already knew: There are no clues or patterns, at least nothing included intentionally by the person who created and funded these wallets...

This already shows the irrelevance of the following miserable attempt to discover a pattern.
[---snip---]

imagine #130 is at 0.9%
if you approached this puzzle with your mindset, you would have failed miserably due to depleted resources, both financial and time. If you had not died before.

Please don't get me wrong, this is not a criticism of your skills but an indication of how people can be misled by a lack of imagination or understanding, especially when it comes to very large numbers.

[WanderingPhilospher]

Ok, so, when I first found out about this puzzle and started looking into it earlier this year, I was initially working under the assumption that there would be some clues or patterns that could be found to help unlock the remaining wallets...

But, of course, I now know what you all already knew: There are no clues or patterns, at least nothing included intentionally by the person who created and funded these wallets...

This already shows the irrelevance of the following miserable attempt to discover a pattern.
[---snip---]

imagine #130 is at 0.9%
if you approached this puzzle with your mindset, you would have failed miserably due to depleted resources, both financial and time. If you had not died before.

Please don't get me wrong, this is not a criticism of your skills but an indication of how people can be misled by a lack of imagination or understanding, especially when it comes to very large numbers.

Almost like 10^18  😉

[alek76]

Please don't get me wrong, this is not a criticism of your skills but an indication of how people can be misled by a lack of imagination or understanding, especially when it comes to very large numbers.

Absolutely right. We can use an example to explain what a very large number looks like. Such numbers will be difficult to visualize in your mind when imagining their quantity. For example:
On planet earth, on all the beaches in the world, the number of grains of sand is 2^77. Now imagine that every grain of sand is planet earth. Now count the number of grains of sand on all planets There are only 2^154. You don’t have to imagine anymore 2^256 is probably the size of the universe in light years

[nomachine]

Cuda can make this number of combinations per second?

You can measure it.

The "mersenne twister" is something that has been especially adapted for Nvidia to use at a thread level within threads of the same warp using thread id calls as seeds. See paper here:
http://developer.download.nvidia.com/compute/cuda/2_2/sdk/website/projects/MersenneTwister/doc/MersenneTwister.pdf

Look here average PRNGs speed
https://developer.nvidia.com/gpugems/gpugems3/part-vi-gpu-computing/chapter-37-efficient-random-number-generation-and-application

In the best case scenario, you will have 26 times over the quad-CPU machine.

And we need PRNGs Average Time:  0.000000000002  seconds to solve Puzzle 66 

And then all other parts of the script no slower than this.

[wipall2]

So, if we find it, from which wallet will we get the contents? Electrom? Or with what wallet? I'm very curious and I don't know. or bitcoin core wallet?

[nomachine]

Combinations is not a random generating! . Besides it's combinations of points on curve, not private keys.

 It is not feasible to directly select points on a curve that correspond to specific private key, especially without knowing the corresponding public key. Without the private key, it is virtually impossible to reverse the process.

On planet earth, on all the beaches in the world, the number of grains of sand is 2^77.

Now imagine people who add and subtract grains of sand to find the unique single grain in the desert (curve) .  

[AlanJohnson]

So, if we find it, from which wallet will we get the contents? Electrom? Or with what wallet? I'm very curious and I don't know. or bitcoin core wallet?

Range number telling how many public key we need for combinations, puzzle 66 needs 66 public keys for combinations, I can make video to proof what I am talking about. There are constant public keys you have to figure out it by yourself. I can share it with the creator of the puzzle for the purpose of this puzzle. I just want say HD wallet not safe because its zero padding system.

Just crack the puzzle then and stop talking ... It starts to be annoying that more and more people here shows weird ideas but in fact they know nothing.

[rosengold]

Just crack the puzzle then and stop talking ... It starts to be annoying that more and more people here shows weird ideas but in fact they know nothing.

agreed. this topic became a land of crazy logics that are just waste of time. to find #66 you need an optimized script with CUDA and enought computing power, everything besides this are just vaporware.

[AlanJohnson]

So, if we find it, from which wallet will we get the contents? Electrom? Or with what wallet? I'm very curious and I don't know. or bitcoin core wallet?

Range number telling how many public key we need for combinations, puzzle 66 needs 66 public keys for combinations, I can make video to proof what I am talking about. There are constant public keys you have to figure out it by yourself. I can share it with the creator of the puzzle for the purpose of this puzzle. I just want say HD wallet not safe because its zero padding system.

Just crack the puzzle then and stop talking ... It starts to be annoying that more and more people here shows weird ideas but in fact they know nothing.

I believe that's the way it should be, everyone has to start from somewhere, *I started my journey here as well. Talking like that to every newbie coming here trying to share ideas and learn is really discouraging. We have to teach them with kindness and patience, otherwise they'd never learn. Besides, this is a forum to talk about things, learn and teach, not a place for a selected few to quickly learn the ultimate tricks and empty all the puzzle keys to place more sats on their stash.
There is a solution for anyone without tolerance to read such posts, if you all just ignore everyone you don't like, then you'll never have to come here at all, because you have problems with everyone. But honestly this is not an accepted behaviour we keep seeing for the past few month. However if you could join the bitching party with your main accounts, then we'd have something to talk about, until then stick to the dig's rules = be kind to everyone and be patient, we'd like to see new comers unlocking their true potentials by our help, not to suppress their talents by such discouraging behaviour.

Note, I'm not pointing fingers at anyone specific, but they know who they are.
Here is the ending humor:
*= that was a mistake to give me room to grow, now you have to live with it. Lolz
Btw, in puzzle 66 there is no public key involved, it's unknown.

First: I believe it's obvious for everyone here that public keys are available only for every 5th address in the whole puzzle. And I also believe eveeryone here understand what does it mean and how it affect the ability of cracking a private key to such address.

As for the rest:  I think in this thread only valuable ideas like new tools or new way of approach to puzzle cracking should be shared. We can't write every thought here cause it will become one big mess.

The worst posts here are pathetic attepmts to sell you a range where a private key lies or some sort of other "valuable" information.

Next one group are posts like yours Digaran where you shows some calculations/substractions/etc. that don't contribute anything constructive into problem solving and nobody understands it.

There is also third annoying group of posts - "mystery posts". Some people like to pretend they know something but they don't want to share it with you now (of course they clearly don't know anything valuable but they like to sound mysterious).

Breaking  the 66 is impossible without MASSIVE computational power -some sort of GPU farm. I wouldn't count on luck here at all. It's all about power (and i guess that was the goal of this cracking challenge confusingly named "puzzle"). All we have here is blind brute forcing.

Breaking 130 is the same despite we have public key available but the range is incredibly massive. All we have here is brute forcing (pointless), BSGS and Kangaroo (pointless until you have hundreds or thousands of GPUs to solve it in resonable time).

[zahid888]

First 4 Bytes of all solved 20:3F puzzle... Someone Notice Something Here ?

Puzzle: 02 frontHex: 00000003 Binary: 000000000000000000000000000011        Zeros: 0        Ones: 2 
Puzzle: 06 frontHex: 00000031 Binary: 000000000000000000000000110001        Zeros: 3        Ones: 3 
Puzzle: 10 frontHex: 00000202 Binary: 000000000000000000001000000010        Zeros: 8        Ones: 2 
Puzzle: 14 frontHex: 00002930 Binary: 000000000000000010100100110000        Zeros: 9        Ones: 5 
Puzzle: 18 frontHex: 0003080d Binary: 000000000000110000100000001101        Zeros: 12       Ones: 6 
Puzzle: 22 frontHex: 002de40f Binary: 000000001011011110010000001111        Zeros: 10       Ones: 12
Puzzle: 26 frontHex: 0340326e Binary: 000011010000000011001001101110        Zeros: 15       Ones: 11
puzzle: 30 frontHex: 3d94cd64 Binary: 111101100101001100110101100100        Zeros: 14        Ones: 16
puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13
puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14
puzzle: 42 frontHex: 2a221c58 Binary: 101010001000100001110001011000        Zeros: 19        Ones: 11
puzzle: 46 frontHex: 2ec18388 Binary: 101110110000011000001110001000        Zeros: 18        Ones: 12
puzzle: 50 frontHex: 22bd43c2 Binary: 100010101111010100001111000010        Zeros: 16        Ones: 14
puzzle: 54 frontHex: 236fb6d5 Binary: 100011011011111011011011010101        Zeros: 11        Ones: 19
puzzle: 58 frontHex: 2c675b85 Binary: 101100011001110101101110000101        Zeros: 14        Ones: 16
puzzle: 62 frontHex: 363d541e Binary: 110110001111010101010000011110        Zeros: 14        Ones: 16

[alek76]

It will be much faster on the E8400 CPU 1 thread.
the mod 12. https://github.com/alek76-2/VanitySearch/tree/main/mod/012


Digaran. When phones with 64-bit CPUs appear, I will port the program code for the phone, especially for you

[lordfrs]

Digaran. When phones with 64-bit CPUs appear, I will port the program code for the phone, especially for you

There is a phone with a 64-bit processor. Don't you know?

Asus ZenFone 2

Intel Atom Z3580
4x 2.33 GHz Atom Z3580    
64-bit

went on sale 8 years ago

[alek76]

There is a phone with a 64-bit processor. Don't you know?

I didn’t know..., that means I’m behind They are not common among all users, we need to wait another 8 years, then 66 bits will be solved and we’ll move on to 67 bits. You can port the code, I think it won’t take much time.
I don't have such a phone to test the program.

[alek76]

Script for check / generating address + wif and hex key. P2PKH Compressed / UnCompressed address.
If you need an address without an online service.
Python 2.7 code:

Code:

#! /usr/bin/env python

import random
from ecdsa.ecdsa import int_to_string
from ecdsa.ecdsa import string_to_int
from binascii import hexlify
import hashlib


class CurveFp( object ):
  def __init__( self, p, a, b ):
    self.__p = p
    self.__a = a
    self.__b = b

  def p( self ):
    return self.__p

  def a( self ):
    return self.__a

  def b( self ):
    return self.__b

  def contains_point( self, x, y ):
    return ( y * y - ( x * x * x + self.__a * x + self.__b ) ) % self.__p == 0

class Point( object ):
  def __init__( self, curve, x, y, order = None ):
    self.__curve = curve
    self.__x = x
    self.__y = y
    self.__order = order
    if self.__curve: assert self.__curve.contains_point( x, y )
    if order: assert self * order == INFINITY
 
  def __add__( self, other ):
    if other == INFINITY: return self
    if self == INFINITY: return other
    assert self.__curve == other.__curve
    if self.__x == other.__x:
      if ( self.__y + other.__y ) % self.__curve.p() == 0:
        return INFINITY
      else:
        return self.double()

    p = self.__curve.p()
    l = ( ( other.__y - self.__y ) * \
          inverse_mod( other.__x - self.__x, p ) ) % p
    x3 = ( l * l - self.__x - other.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
    return Point( self.__curve, x3, y3 )

  def __mul__( self, other ):
    def leftmost_bit( x ):
      assert x > 0
      result = 1L
      while result <= x: result = 2 * result
      return result / 2

    e = other
    if self.__order: e = e % self.__order
    if e == 0: return INFINITY
    if self == INFINITY: return INFINITY
    assert e > 0
    e3 = 3 * e
    negative_self = Point( self.__curve, self.__x, -self.__y, self.__order )
    i = leftmost_bit( e3 ) / 2
    result = self
    while i > 1:
      result = result.double()
      if ( e3 & i ) != 0 and ( e & i ) == 0: result = result + self
      if ( e3 & i ) == 0 and ( e & i ) != 0: result = result + negative_self
      i = i / 2
    return result

  def __rmul__( self, other ):
    return self * other

  def __str__( self ):
    if self == INFINITY: return "infinity"
    return "(%d,%d)" % ( self.__x, self.__y )

  def double( self ):
    if self == INFINITY:
      return INFINITY

    p = self.__curve.p()
    a = self.__curve.a()
    l = ( ( 3 * self.__x * self.__x + a ) * \
          inverse_mod( 2 * self.__y, p ) ) % p
    x3 = ( l * l - 2 * self.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
    return Point( self.__curve, x3, y3 )

  def x( self ):
    return self.__x

  def y( self ):
    return self.__y

  def curve( self ):
    return self.__curve
  
  def order( self ):
    return self.__order
    
INFINITY = Point( None, None, None )

def inverse_mod( a, m ):
  if a < 0 or m <= a: a = a % m
  c, d = a, m
  uc, vc, ud, vd = 1, 0, 0, 1
  while c != 0:
    q, c, d = divmod( d, c ) + ( c, )
    uc, vc, ud, vd = ud - q*uc, vd - q*vc, uc, vc
  assert d == 1
  if ud > 0: return ud
  else: return ud + m

# secp256k1
_p  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FL
_r  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141L
_b  = 0x0000000000000000000000000000000000000000000000000000000000000007L
_a  = 0x0000000000000000000000000000000000000000000000000000000000000000L
_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798L
_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8L

class Public_key( object ):
  def __init__( self, generator, point ):
    self.curve = generator.curve()
    self.generator = generator
    self.point = point
    n = generator.order()
    if not n:
      raise RuntimeError, "Generator point must have order."
    if not n * point == INFINITY:
      raise RuntimeError, "Generator point order is bad."
    if point.x() < 0 or n <= point.x() or point.y() < 0 or n <= point.y():
      raise RuntimeError, "Generator point has x or y out of range."

curve_256 = CurveFp( _p, _a, _b )
generator_256 = Point( curve_256, _Gx, _Gy, _r )
g = generator_256

b58_digits = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

### generate privkey
randrange = random.SystemRandom().randrange
n = g.order()
#n = 115792089237316195423570985008687907852837564279074904382605163141518161494337

ripehash = hashlib.new('ripemd160')	

def b58encode(b):
    
	n = int('0x0' + hexlify(b).decode('utf8'), 16)
	res = []
	while n > 0:
		n, r = divmod (n, 58)
		res.append(b58_digits[r])
	res = ''.join(res[::-1])
	import sys
	czero = b'\x00'
	if sys.version > '3':
		czero = 0
	pad = 0
	for c in b:
		if c == czero: pad += 1
		else: break
	return b58_digits[0] * pad + res

###

#Compress_fl = 0 # UNCompressed
Compress_fl = 1 # Compressed

### Start generate secret
password = "123" # SET PASSWORD -----------------------!!!!!!!!!!!!!!!!!!!!!----------------------- SET PASSWORD
#password = raw_input('Your string here:')
sha1 = hashlib.sha256(password).digest()
temp1 = string_to_int(sha1)
secret_bw = temp1 # brainwallet
### End generate secret

#secret = secret_bw # brainwallet

secret = randrange( 1, 2**256 )

### SET SECRET KEY ###
### SET SECRET KEY ###
### SET SECRET KEY ###
### SET SECRET KEY ###
### SET SECRET KEY ###

#secret = 0xf13b87e9L # PointX len 62

#secret = 0xF7051F27B09112D4

### SET SECRET KEY ###
print '====================================================================================='
print 'Secret Key: '
print hex(secret)
print '====================================================================================='

### generate pubkey
myp = g * secret
### generate address

print "Points: "

px_str = hex(myp.x())[2:-1]
py_str = hex(myp.y())[2:-1]

while len(px_str) < 64:
    #print 'px_str: ', len(px_str)
    px_str = '0' + px_str

while len(py_str) < 64:
    #print 'py_str: ', len(py_str)
    py_str = '0' + py_str

print px_str
print py_str

print '====================================================================================='

# if Compressed address
if myp.y() % 2 == 0:
	y_parity = '\x02'
	pk_y_parity = '02'
	#print "02" + px_str
else: 
	y_parity = '\x03'
	pk_y_parity = '03'
	#print "03" + px_str

# Public Key
if Compress_fl:
    pk = pk_y_parity + px_str
else:
    pk = '04' + px_str + py_str
print 'Public Key: '
print pk
print '====================================================================================='

# !!! NORMALIZE Length !!!
print 'NORMALIZE Length PointX and PointY'
# Point X
px_string = int_to_string(myp.x())

if len(px_string) < 32:
    print 'NORMALIZE Length PointX: ', len(px_string)

while len(px_string) < 32:
    px_string = '\x00' + px_string

print 'Check len PointX: ', len(px_string)

# Point Y
py_string = int_to_string(myp.y())

if len(py_string) < 32:
    print 'NORMALIZE Length PointY: ', len(py_string)

while len(py_string) < 32:
    py_string = '\x00' + py_string

print 'Check len PointY: ', len(py_string)

print '====================================================================================='

if Compress_fl:
    step1_mod = y_parity + px_string  # Compressed
else:
    step1_mod = '\x04' + px_string + py_string # UNCompressed

# End

step2 = hashlib.sha256(step1_mod).digest()

print "Pubkey sha256: "
istep2 = string_to_int(step2)
Psha256 = hex(istep2)[2:-1]
print Psha256
print '====================================================================================='

ripehash.update(step2)
step3 = ripehash.digest()
address160 = hex(string_to_int(step3))[2:-1]
print "Address hash160: "
print address160
step4 = '\x00' + ripehash.digest()
step5 = hashlib.sha256(step4).digest()
step6 = hashlib.sha256(step5).digest()
chksum = step6[:4]
addr = step4 + chksum
address = b58encode(addr) 
#print address
### Convert private key to wallet import format
wif1 = int_to_string(secret)
i = 0;
while  i < (64 - len(hex(secret)[2:-1])) / 2:
	wif1 = '\x00' + wif1
	i = i + 1
		
#wif2 = '\x80' + wif1
# Compressed privkey
if Compress_fl:
    wif2 = '\x80' + wif1 + '\x01' # Compressed privkey
    addr_mode_str = 'Compressed'
else:
    wif2 = '\x80' + wif1 #        # UNCompressed privkey
    addr_mode_str = 'UnCompressed'

wif3 = hashlib.sha256(wif2).digest()
wif4 = hashlib.sha256(wif3).digest()
wif5 = wif4[:4]
wif6 = wif2 + wif5
wif = b58encode(wif6) 
#print wif
### Save address and private key in priv.txt
hexsecret = hex(secret)

file_name = 'p_r_v.txt'

f = open(file_name, 'a')
f.write('\n'.join([addr_mode_str + ' Address: ' + address, 'Address hash160:    ' + address160, 'Secret wif: ' + wif, 'Secret hex: ' + hexsecret, 'PK: ' + pk, \
                   'Px: ' + px_str, 'Py: ' + py_str + '\n\n' ]))
f.close()
print '====================================================================================='
print 'Save ' + addr_mode_str + ' Address: ' + address
print 'Save Address hash160:    ' + address160
print 'Save WIF PrivKey: ' + wif
print 'Save Hex PrivKey: ' + hexsecret
print 'Save Public Key:  ' + pk
print '====================================================================================='
raw_input("... Press Enter")
raise SystemExit

Result output + write in file p_r_v.txt

Code:

Compressed Address: 18cdpW3P6imyDz6w622nYAGXvSznCM5om9
Address hash160:    53862c90c2a994c7a874bb091f9b8e51fcdaa06c
Secret wif: L3zSyzX1ky3QbEcvC6fHE9eDyuznswoDCsvGvCeiTuH2fkmN3L2G
Secret hex: 0xca0a0ca7838e9dfee4aaa0cfbee29b69a8f67dae595d993a71fdaab4a01287e2L
PK: 029c5b2d21be2b2bbeca4ac1cf1233c591e1127a355cdd564c880e88f98985efe7
Px: 9c5b2d21be2b2bbeca4ac1cf1233c591e1127a355cdd564c880e88f98985efe7
Py: 3c36a84972cbe787b26822596014625fa801981f38c56597d0c03f38f3ee93bc

Compressed Address: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
Address hash160:    3ee4133d991f52fdf6a25c9834e0745ac74248a4
Secret wif: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZ6FxoaD5r1kYegmtbaT
Secret hex: 0xf7051f27b09112d4L
PK: 03100611c54dfef604163b8358f7b7fac13ce478e02cb224ae16d45526b25d9d4d
Px: 100611c54dfef604163b8358f7b7fac13ce478e02cb224ae16d45526b25d9d4d
Py: 5127c2d0b1c4a4d5b4996bbdf37633b86901d0303b61e2f6f0772282ae08ff95

Hello all, is there any python code for public key addition and checking it's hash ?

Yes, look at the iceland2k14/secp256k1 script and create your script to fit within his script.

Also, what do you mean by "checking it's hash"? H160?

Yes , hash160 . I saw his code , I am just good at math but very bad at programming so I couldn't understand the code honestly

Simplest

Code:

import sys, secrets, secp256k1 as ice
while True:
    dec = secrets.SystemRandom().randrange(36893488147419103231, 73786976294838206463)
    h160 = ice.privatekey_to_h160(1, True, dec).hex()
    message = "\r{}".format(h160);messages = []
    messages.append(message);output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output);sys.stdout.flush()
    if h160 == "20d45a6a762535700ce9e0b216e31994335db8a5":
        HEX = "%064x" % dec;wifc = ice.btc_pvk_to_wif(HEX)
        with open("KEYFOUNDKEYFOUND.txt", "a") as f:
          f.write(f'Private key (wif) Compressed : {wifc}\n')
        break

Im found ERROR. The code search address type P2SH. Still looking for a P2SH address?
For search P2PKH address replace str:

Code:

h160 = ice.privatekey_to_h160(1, True, dec).hex()

to str:

Code:

h160 = ice.privatekey_to_h160(0, True, dec).hex()

Code:

def _privatekey_to_h160(addr_type, iscompressed, pvk_int):
    # type = 0 [p2pkh],  1 [p2sh],  2 [bech32]

I don’t want to upset anyone, but many people make similar mistakes when they are in a hurry. To be honest, I only noticed the error myself.
The main thing is that 1000 kW hours of energy were not wasted. Please