Yes, absolutely!  That IS stupid. I don't understand why so many people in here insist and keep trying to find similar strings whose hash value only approximates the target hash value. This is a pure waste of time, nerves and resources as it does not contribute in any way - not even in the slightest - to speeding up or even impairing the solution finding process.

The following two strings demonstrate the avalanche effect. Even if you add the punctuation "." at the end of the sentence and thus changing the string slightly, it'll produce a complete different hash.

This is stupid
f061b6de6d36df2330b1ba15dca3cf858c7e20a2935e453668c6b7124e58d80b

This is stupid.
dbf61110bee7b482f8b5536d4996effaae1de69fcd5e132c0d3af1ebf7146b3d

Imagine you find the string of the hash f061b6de6d36df2330b1ba15dca3cf858c7e20a2935e453668c6b7124e58d80b
f061b6de6d36df2330b1ba15dca3cf858c7e20a2935e453668c6b7124e58d80c

never ever it will be similar to the real string "This is stupid". The string for this hash could be "something completely different in ch4rs and s!ze"

Please stop looking for prefixes, suffixes or parts of hashes because it's a waste of time. Instead, invest your strength and energy and read about the avalanche effect.

So true ...

puzzled? no, huh?

anyone's welcome here despite of their origin and native language. Have fun and enjoy and last but not least ... Good luck!
Cheers

Addresses and private keys are not directly related, even if you find 34 characters out of 35 characters you can't find the private key! Happy hunting.😉

Absolutely, so it seems that the amount of valid public x-coords is exactly half the amount of private keys.
So as the theory is any key in the full range (1-115792089237316195423570985008687907852837564279074904382605163141518161494336 ~2^256) either it is less than half (57896044618658097711785492504343953926418782139537452191302581570759080747168) or has the same x coordinate as one that does (above 57896044618658097711785492504343953926418782139537452191302581570759080747169).

I have a mathematical function to find the resulting twin on either side.
I really do like the work that has been done here on the Kangaroo software so I will provide my python function for reference of finding said twin so long as you know 1 of 2 private keys you will know both.

~2^255 is still a very large number.
In the case of uncompressed keys you still have to compute the y coord after but it is trivial.
(using the bit library for python as the function is not intensive)

from bit import Key
import secrets
def twin(i, pubhex):
    max = 115792089237316195423570985008687907852837564279074904382605163141518161494336
    if len(pubhex) == 66:
        publichex = str(pubhex)[2:66]
        if i < 57896044618658097711785492504343953926418782139537452191302581570759080747169:
            twin = max - (i-1)
            if str(pubhex)[:2] == '02':
                twinprefix = '03'
                return [twin,f'{twinprefix}{publichex}']
            elif str(pubhex)[:2] == '03':
                twinprefix = '02'
                return [twin, f'{twinprefix}{publichex}']
        elif i > 57896044618658097711785492504343953926418782139537452191302581570759080747168:
            twin = 1 + (max-i)
            if str(pubhex)[:2] == '02':
                twinprefix = '03'
                return [twin,f'{twinprefix}{publichex}']
            elif str(pubhex)[:2] == '03':
                twinprefix = '02'
                return [twin,f'{twinprefix}{publichex}']
    elif len(pubhex) == 130:
        publichex = str(pubhex)[2:66]
        if i < 57896044618658097711785492504343953926418782139537452191302581570759080747169:
            twin = max - (i-1)
            return [twin,f'uncomp,{publichex}']
        elif i > 57896044618658097711785492504343953926418782139537452191302581570759080747168:
            twin = 1 + (max-i)
            return [twin, f'uncomp,{publichex}']

max = 115792089237316195423570985008687907852837564279074904382605163141518161494336
for x in range(100):
    q = secrets.randbelow(max)
    k = Key.from_int(x)
    t = twin(x,k.pub_to_hex())
    pt = t[0]
    ptpub = Key.from_int(pt).pub_to_hex()
    print(t[1],ptpub)

'''
# Or you can do this
for x in range(1000):
    x = secrets.randbelow(max)
    k = Key.from_int(x)
    t = twin(x,k.pub_to_hex())
    pt = t[0]
    ptpub = Key.from_int(pt).pub_to_hex()
    assert t[1] == ptpub
'''

'''
# for uncompressed
for x in range(100000):
    x = secrets.randbelow(max)
    k = Key.from_int(x)
    k._public_key = k._pk.public_key.format(compressed=False)
    t = twin(x,k.pub_to_hex())
    pt = Key.from_int(t[0])
    # this next line is not nessicary as we format the response without the leading '04'
    pt._public_key = pt._pk.public_key.format(compressed=False)
    ptpub = pt.pub_to_hex()
    assert t[1] == f'uncomp,{str(ptpub)[2:66]}'
'''

I found a method to find any private key within 2^255 bit space. Is that new?

The birthday paradox works on a similar principle d i don't know now i have pasted this code for fun

from bit import Key
for xx in range(1):
 q = 1
 for x in range(200):
  for y in range(170,200):
   probability = x / y
   q *= (1 - probability)
   p = 1 - q
   for cc in range(922,1845):
    x0 = ''.join(str(cc))
    x1 = ''.join(str(p))[2:]
    ke = Key.from_int(int(x0+x1))
    if (str(ke)).endswith("QN>"): # this print all bitcoin address they end big N> use this XQN> code run faster
     print(x0+x1,ke,x,y)
    if (str(ke)) == "<PrivateKey: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN>":
     f=open("win.txt","a")
     f.write(str(x0+x1)+(str(ke))+"\n")
     f.close()

the key of puzzle # 64 is found

between 10000000000000000000 --- 14000000000000000000
hex
0000000000000000000000000000000000000000000000008AC7230489E80000 --- 000000000000000000000000000000000000000000000000C249FDD327780000


If the information helps you and you can solve it, if you want to thank, send here 3QWcjuY72EyouLmkRY4FbuoM1V7mA6tyqv

This is my python script for searching puzzle 64 it's generating an .bat file with  random keyspace between puzzle64 keyrange. I'm using vanity + bitcrack


just place vanity + bitcrack in the same folder name vanity.exe an run the .bat file


Good luck guys

When using Python, I use FastEcdsa(https://github.com/AntonKueltz/fastecdsa) library and mathematics similar to Sage. But can I do the math faster? I want to understand.
The FastEcdsa Library is fast, but I don't know if it uses the gmpy2 you suggested. My python script uses 17% of the CPU as a result. I wanted to write with Anaconda (for GPU), but I could not find a gpu running as fast as C or I could not.

Thank you MrFreeDragon .

Address 64 has no outgoing transactions.Therefore, the public key is unknown.

Pollard Kangaroo algorithm needs as input a public key and an interval for private key.

So... you don't use kangaroo without pub key.

One can get a public key from spent transaction, or early P2PK transaction.

In case of your example you can't find the pubkey of the address 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN. That's because it is a Pay 2 Public Key Hash address. What you tried to do I guess is a base58 decode of the address. The tool at http://gobittest.appspot.com/Address might be of help to you fur understanding purposes. Just fill in the address in the last field and you will get the values all the way to the RIPEMD-160 of the hash of the private key. But since RIPEMD and SHA are hashing algorithms that will only work in one way there is no way you can calculate the public key.

In case of a P2PKH address the public key becomes known when the address is used for an outgoing transaction. In that case for the unlocking script the public key has to be supplied and it will be checked if it hashes to the correct value. But in your case the address doesn't have any outgoing transactions so the public key is not known to anyone but the person who also has the private key.

In case of your example you can't find the pubkey of the address 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN. That's because it is a Pay 2 Public Key Hash address. What you tried to do I guess is a base58 decode of the address. The tool at http://gobittest.appspot.com/Address might be of help to you fur understanding purposes. Just fill in the address in the last field and you will get the values all the way to the RIPEMD-160 of the hash of the private key. But since RIPEMD and SHA are hashing algorithms that will only work in one way there is no way you can calculate the public key.

In case of a P2PKH address the public key becomes known when the address is used for an outgoing transaction. In that case for the unlocking script the public key has to be supplied and it will be checked if it hashes to the correct value. But in your case the address doesn't have any outgoing transactions so the public key is not known to anyone but the person who also has the private key.

For Windows:

Example of input text document that contains ranges and public key you are searching for, let's call it/save it as input.txt:

1000000 = start of range
1FFFFFF  = end of range
03057... = public key you are searching for

Save the input text document in same folder as Kangaroo.exe

Kangaroo doesn't search for an address but a public key.

I think this is f***ng incredible think, just need to use it write a way! man thanks! but i got some questionsm but it still doing what i really need
 pm me