Bitcoin puzzle transaction ~32 BTC prize to who solves it

[r1ckpwn]

Dear @WanderingPhilospher please tell me what happened with stride in VanBitCracken, I have absolutely no idea how difficult this task is. But I hope that you will definitely be able to do it.

I have yet to figure it out. Therefore, I had to create my stride function with the help of python lol...python creates next stride; but this is not as fast as if it were built into the program.

program, python stride, program, python stride, etc.

is there a pool or group chat for 125? id love to toss my fire power with yours at this.

Hi, yes there is in development a pool for #125 puzzle. If you want to follow me, DM me.

i cant dm because im a newbie to this group you would have to pm me.

my telegram: @rickpwn

[1714658886]

1714658886

[citb0in]

why was the last post of "Professor of wilds" here about puzzle #66 deleted? To the poster: please write again your proposal about the key search and the list you posted

[GR Sasa]

Puzzle 66 is really low a LOT with its prize. Satoshi could've increased the price by 10x again so it'll be worth the time and electricity we are investing on it.

I would love to give a suggestion to Satoshi again.

I'd take all unsolved puzzle coins from 101 to 160 and add them to the unsolved parts that are under 100 bits.

I think the maximum is 100 bits we can crack without a public key, so it'll be worth the mention.

Thanks Satoshi,

Who agree? guys merit me so Satoshi can see and take actions

[lostrelic]

why was the last post of "Professor of wilds" here about puzzle #66 deleted? To the poster: please write again your proposal about the key search and the list you posted

Just came back to this thread and yes the post has gone???

[digaran]

Puzzle 66 is really low a LOT with its prize. Satoshi could've increased the price by 10x again so it'll be worth the time and electricity we are investing on it.

I would love to give a suggestion to Satoshi again.

I'd take all unsolved puzzle coins from 101 to 160 and add them to the unsolved parts that are under 100 bits.

I think the maximum is 100 bits we can crack without a public key, so it'll be worth the mention.

Thanks Satoshi,

Who agree? guys merit me so Satoshi can see and take actions

I'd like some virgins as topping on the cake as well! Lol. People and their expectations, I forgot to ask satoshi to pass the salt over!🤣
These puzzles are not to solve  and collect the prize, they exist so that we don't go wandering around emptying people's addresses! But seriously ever since the increase, I have stopped looking for lost wallets, but that's temporary as soon as AWD team cracks all the puzzles, we will continue our effort, which is taking names kicking ass.😂

[lostrelic]

Who is awd?

[r1ckpwn]

Hello,
is there any pool where we can combine all our gpus to bruteforce a puzzle?

hi yes we're working on a pool based with kangaroo write me on telegram @rickpwn

[GR Sasa]

Sorry - but still not possible. even if you combine 1,000 GPUs for puzzle 125 using Kangaroo, you still would need to solve approx 63 bits, which equals to many many years of searching.

[WanderingPhilospher]

And even better, what if we can apply the prefix concept on hash160 too. Instead of looking for address prefix, we look for hash160 prefix. Even more speed. In fact, this would be the fastest way ever.

Won't work, rmd160 has 40 characters and by searching for their prefix, should we stop hashing half way? Meaning converting sha256 hash of public key into rmd160 but only looking for a specific prefix, either we generate the whole hash and compare with our target or we can't generate just a prefix to compare because it would break the function and we wouldn't know the result.

About brute force tools, bitcrack, vanity etc they all convert rmd160 to address, otherwise why would they accept an address as an input to check against?

Ok, after digging through bitcrack code to look at its stride function, I did find where it converts all addresses provided to rmd160...

Code:

// Convert each address from base58 encoded form to a 160-bit integer
	for (unsigned int i = 0; i < targets.size(); i++) {

		if (!Address::verifyAddress(targets[i])) {
			throw KeySearchException("Invalid address '" + targets[i] + "'");
		}

		KeySearchTarget t;

		Base58::toHash160(targets[i], t.value);

		_targets.insert(t);
	}

	_device->setTargets(_targets);
}

[WanderingPhilospher]

Sorry - but still not possible. even if you combine 1,000 GPUs for puzzle 125 using Kangaroo, you still would need to solve approx 63 bits, which equals to many many years of searching.

Nah...1,000 GPUs, at 1,000 MKey/s (RTX 30xx, RTX 2080s, 2070s, etc, can attain these speeds), would solve #125 in roughly 160 days.

[Andzhig]

Well, for 6-7 years, all possible options have already been sorted out, or combinatorics to sort out (shuffle 111112233... 222221133.. 332222211... etc) or to be smart about something with collisions.

for example, we can choose from a random house any number of times


random.seed(36893488147419103232,73786976294838206464)
random.randrange(36893488147419103232,73786976294838206464,1)

etc

36893488147419103232×36893488147419103232 = 1361129467683753853853498429727072845824

random.seed(36893488147419103232,1361129467683753853853498429727072845824)
random.randrange(36893488147419103232,73786976294838206464,1)

etc

in other words, there 1361129467683753853853498429727072845824 are so many collisions 36893488147419103232

now we take this number and we need to fish out the collisions we need

random.seed(36893488147419103232,73786976294838206464)
random.randrange(1,1361129467683753853853498429727072845824 ,1)

to

random.seed(random.randrange(1,1361129467683753853853498429727072845824 ,1))
random.seed(36893488147419103232,73786976294838206464)


1361129467683753853853498429727072845824×1361129467683753853853498429727072845824 = 1852673427797059126777135760139006525652319754650249024631321344126610074238976

there will be such sections in this number where the first step by step will be collisions (36893488147419103232×36893488147419103232 = 1361129467683753853853498429727072845824)

36893488147419103232×36893488147419103232 = 1361129467683753853853498429727072845824
****************** ___________________      ****************** ___________________

there will be areas

****************** ___________________

**********___________________*********

_______*******_______********_________

*_*_*_*_*_*_*_*_**__**__**__***___***

etc...

well, according to the law of uniform distribution, somehow jump there, random means uniform distribution over space.

from os import system
system("title "+__file__)
import random
import time
#from bit import Key
#from combi import *

import gmpy2
import secp256k1 as ice


list2 = ["13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"]

F1="01"

aa1=F1[0]*70
aa2=F1[1]*70

def find_permutation(lst,K,numberbit1,numberbit0):

    l = lst

    N = numberbit0
    M = numberbit1

    if N == len(l):
        return F1[1] * N
   
    if M == len(l):
        return F1[1] * M

    result = ''   

    for i in range (0, len(lst)-1):
        K0 = gmpy2.comb(len(l)-1, M)

        if (K < K0):
            result += F1[0]
            l.remove (F1[0])
        else:
            result += F1[1]
            l.remove (F1[1])
            M -=1
            K = K - K0

    result += l[0]

    return result

#count = 0
#5444517870735015415413993718908291383296  2^66×2^66
#93820969697840041204785894580506297666600 140!/70!/70!

while True:
   
    random.seed()
    sssakkki = random.randrange(1,73786976294838206464,1)
    saki = 73786976294838206464 * sssakkki
   
    print("")
    print("")
    print("")
    print(sssakkki,saki,"step",5444517870735015415413993718908291383296//saki)
    #time.sleep(random.randrange(1,10,1))

   
    X2=0 #X=10
    while X2 <= 5444517870735015415413993718908291383296:

        X=X2 #X=10
        while X <= X2: #+1000
                   
            a3 = list(aa1+aa2)
            K = X #perm_int
            numberbit1 = len(aa1)
            numberbit0 = len(aa2)

            aa = find_permutation(a3,K,numberbit1,numberbit0)
            random.seed(aa)

            b = random.randrange(36893488147419103232,73786976294838206464,1)

           
            if b >= 36893488147419103232:
                   
                    #key = Key.from_int(b)
                addr = ice.privatekey_to_address(0, True, b) #key.address
                           
                if addr in list2:
                               
                    print ("found!!!",b,addr)
                    s1 = str(b)
                    s2 = addr
                    f=open("a.txt","a")
                    f.write(s1)
                    f.write(s2)       
                    f.close()
                    pass
                else:
                    #pass
                    print(b,addr) #print(X,r1,b,addr)

               
            X=X+1


        X2=X2+saki
       
        #print("")
        #print(X2)
        #print("")

 

[digaran]

Problem is not with full addresses, the problem is with vanity engine searching for prefixes, when we input 7-10 characters to find a match, it has to perform a double hash which according to Evillo's benchmarking, a double hash takes around 5% of the whole speed, while 5% might be a fraction of hundreds of MK/s for some, but imagine those running with 1MK/s, your tiny 5% is equal to 50 people with 1MK/s, given you only have one card with a speed of 1000MK/s.
However those discussions are irrelevant now because brute force is not the answer, what we need to focus on is finding mathematical shortcuts which I believe already exist, we haven't looked hard enough yet.

One possible method I can think of is multiplying public keys, I don't know how is it possible to multiply a key with another key while their combined values goes beyond the range if EC.

My guess is that, they go round the curve circling around forever, which brings me to using a tool like keyhunt, something to use very large strides searching for collisions.

I don't know if you guys are aware of this, almost 50% of public keys share the same X, with a reversed Y value, but the counterpart resides on the other side of the curve, and I think I have found a public key which in uncompressed mode works fine but converting the compressed key to uncompressed key does not work. There are some strange public keys starting with 30 up to 40 zeros, which again baffles my mind about the possibility of such keys existing. Lol

Edit:
Example of a strange public key:

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c

Find their difference, also after that check 69 and 96 as hex, convert them to decimal and compare their values and difference in values, as I have said before this is an ocean, and somehow the designers of EC and the math involved either used magic to come up with these equations, or I am still unable to fathom  the infrastructure underneath them all, yet.  Do not rely on existing tools, if you can come up with new solutions, share them if they can not be used to endanger coins other than puzzle coins. Otherwise you should not reveal anything if it can be exploited to steal coins from people.

[GR Sasa]

Edit:
Example of a strange public key:

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c

Find their difference, also after that check 69 and 96 as hex, convert them to decimal and compare their values and difference in values, as I have said before this is an ocean, and somehow the designers of EC and the math involved either used magic to come up with these equations, or I am still unable to fathom  the infrastructure underneath them all, yet.  Do not rely on existing tools, if you can come up with new solutions, share them if they can not be used to endanger coins other than puzzle coins. Otherwise you should not reveal anything if it can be exploited to steal coins from people.

That's bullshit mate. These are freaking completely normal VALID public keys and have of course private keys that are connected to the them. There is nothing strange with them or what so ever....

Just because a public key has many zeros does not make it "weird" or "strange".


Here's a VALID private key with many zeros. Is it weird?

Code:

000000000000000000000000000000000ffff000000000001111111111100000

[cryptoDEADBEEFFFFF]

Edit:
Example of a strange public key:

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c

Find their difference, also after that check 69 and 96 as hex, convert them to decimal and compare their values and difference in values, as I have said before this is an ocean, and somehow the designers of EC and the math involved either used magic to come up with these equations, or I am still unable to fathom  the infrastructure underneath them all, yet.  Do not rely on existing tools, if you can come up with new solutions, share them if they can not be used to endanger coins other than puzzle coins. Otherwise you should not reveal anything if it can be exploited to steal coins from people.

That's bullshit mate. These are freaking completely normal VALID public keys and have of course private keys that are connected to the them. There is nothing strange with them or what so ever....

Just because a public key has many zeros does not make it "weird" or "strange".


Here's a VALID private key with many zeros. Is it weird?

Code:

000000000000000000000000000000000ffff000000000001111111111100000

It's actually interesting to see public keys that follow this pattern. The keys produce the following addresses when they are uncompressed:

Code:

./calculatefrompublickey 0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3
address 16qakrWzEAPvDsY1yMdCrkgAWZ6DxpTK4z

./calculatefrompublickey 0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c
address 14szHdohyNkdE3XdiwUw1wNmuBUamPBXiS

at compressed format they produce the following addresses (and they had an out transaction meaning they have a valid private key)

Code:

./calculatefrompublickey 0200000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63
address 13see6qjfupx1YWgRefwEkccZeM8QGTAiJ
./calculatefrompublickey 0300000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63
address 1LVAsnUyEtJgZ9HzLfbtiJZuZMzHLX1n6k

[Evillo]

Edit:
Example of a strange public key:

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c

Find their difference, also after that check 69 and 96 as hex, convert them to decimal and compare their values and difference in values, as I have said before this is an ocean, and somehow the designers of EC and the math involved either used magic to come up with these equations, or I am still unable to fathom  the infrastructure underneath them all, yet.  Do not rely on existing tools, if you can come up with new solutions, share them if they can not be used to endanger coins other than puzzle coins. Otherwise you should not reveal anything if it can be exploited to steal coins from people.

That's bullshit mate. These are freaking completely normal VALID public keys and have of course private keys that are connected to the them. There is nothing strange with them or what so ever....

Just because a public key has many zeros does not make it "weird" or "strange".


Here's a VALID private key with many zeros. Is it weird?

Code:

000000000000000000000000000000000ffff000000000001111111111100000

It's actually interesting to see public keys that follow this pattern. The keys produce the following addresses when they are uncompressed:

Code:

./calculatefrompublickey 0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3
address 16qakrWzEAPvDsY1yMdCrkgAWZ6DxpTK4z

./calculatefrompublickey 0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c
address 14szHdohyNkdE3XdiwUw1wNmuBUamPBXiS

at compressed format they produce the following addresses (and they had an out transaction meaning they have a valid private key)

Code:

./calculatefrompublickey 0200000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63
address 13see6qjfupx1YWgRefwEkccZeM8QGTAiJ
./calculatefrompublickey 0300000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63
address 1LVAsnUyEtJgZ9HzLfbtiJZuZMzHLX1n6k

Just like there is invalid private keys, specifically those after the key fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140 .. there are also invalid public keys. The reason is  there are pub keys that lie outside the curve. But i gotta agree that the mentioned pubs above are interesting, especially knowing that one of their addresses is a used one. The only thing I'm not so fond of is the idea of.trying to figure out a mathematical formula to solve the puzzle. Sometimes it's possible to find a pattern in chaos, but most times you can't.

 It feels weird for me to say that especially that i believe numbers are the solution to everything and the base behind the universe existence. I once was joking saying to my cousin that God is Math! Lol.

Problem with big numbers like the ones we're dealing with right now is it's bigger than human imagination. The lowest number of keys we're going after here is #66 which evaluates to 36.8 Million Trillions. And according to WanderingPhilosopher's calculations, the lowest number here is #125, using kangaroo, this number has gotten smaller: 2^63.05 .. if we manage to solve any of these two puzzles, we will literally make history.

[_Counselor]

Example of a strange public key:

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3

Code:

0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c

Just like there is invalid private keys, specifically those after the key fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140 .. there are also invalid public keys. The reason is  there are pub keys that lie outside the curve. But i gotta agree that the mentioned pubs above are interesting, especially knowing that one of their addresses is a used one. The only thing I'm not so fond of is the idea of.trying to figure out a mathematical formula to solve the puzzle. Sometimes it's possible to find a pattern in chaos, but most times you can't.

These are perfectly normal public keys that lie on a curve. Their private keys are 7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 and 7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1

[digaran]

fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140 .. there are also invalid public keys. The reason is  there are pub keys that lie outside the curve. But i gotta agree that the mentioned pubs above are interesting, especially knowing that one of their addresses is a used one.

There is no such a thing as invalid private or public key, whatever private key you think is invalid or outside the range, I will prove you wrong if you just show it to me.

About the keys above, here are 2 private keys, one will open one of the above, I just changed the X on the original one it converted to it's mirror version.

Code:

7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0

If you have seen the start range, end range for bitcoin keys, the above is the middle range.😉

The strange public key which I'm sure has a solution to it, when I try to convert from compressed to uncompressed I get an error.

Code:

0400000000000000000000001dbc672b1fc4d076ca0a7ad5145686cb6b3cafce319f9cbcdfb95741014c1ee4c4d763f97f976c8deeb4e7017e03806508072ceef9

Code:

0300000000000000000000001dbc672b1fc4d076ca0a7ad5145686cb6b3cafce31

[rexxx97]

How many keys/s does the 4090 can do with vanitysearch or bitcrack?

[GR Sasa]

The strange public key which I'm sure has a solution to it, when I try to convert from compressed to uncompressed I get an error.

Code:

0400000000000000000000001dbc672b1fc4d076ca0a7ad5145686cb6b3cafce319f9cbcdfb95741014c1ee4c4d763f97f976c8deeb4e7017e03806508072ceef9

Code:

0300000000000000000000001dbc672b1fc4d076ca0a7ad5145686cb6b3cafce31

neither the uncompressed public key is valid nor the compressed one. Both pub keys are invalid and does not lie inside the curve

[GR Sasa]

How many keys/s does the 4090 can do with vanitysearch or bitcrack?

About 1500 - 1800M per card