Bitcoin puzzle transaction ~32 BTC prize to who solves it

[MoreForUs]

MoreForUs, what speed are you showing with your program? When I ran it a few times, it seems very slow, and the text is somewhat confusing.
What is considered an iteration, one key checked?
Also:

Code:

Reached 12 iterations.
Elapsed Time: 0.53 seconds
Iterations per Second: 22.43
Decimal Number: 37120000000000000000
Private Key Hex: 0000000000000000000000000000000000000000000000020324bb546e800000
Target Hash 160: 09d19b3025828bca263e80cf2b5da1e08e938ca3
Target Decimal Number: 37120000000000000000

Reached 170 iterations.
Elapsed Time: 14.13 seconds
Iterations per Second: 12.03
Decimal Number: 38700000000000000000
Private Key Hex: 000000000000000000000000000000000000000000000002191204f5679e0000
Target Hash 160: 846874d169173600744fe5c1cdf9f2915cdb25ae
Target Decimal Number: 38700000000000000000

The Target Hash 160 verbiage is misleading, as it's not the target 160, it's the actual 160 of the current Private Key Hex being checked. Same for Target Dec Num, if we knew the target, we wouldn't be talking lol.

Anywho, I am trying to compare it's speed to my old slow python script; I think mine checks 3,000 key/s on a single core.

I am getting about 300 keys per second, currently looking into speeding it up. 1 way would be to reduce all of the additional hex keys i am searching for.
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ] its also written like that, so when a match is found it will print verbatim.

[1715289010]

1715289010

[1715289010]

1715289010

[1715289010]

1715289010

[1715289010]

1715289010

[1715289010]

1715289010

[1715289010]

1715289010

[WanderingPhilospher]

I am getting about 300 keys per second, currently looking into speeding it up. 1 way would be to reduce all of the additional hex keys i am searching for.
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ] its also written like that, so when a match is found it will print verbatim

Mine does the same as yours. But I only have it programmed up to #69.
But I do not have all the additional hex numbers; I merely use a stride of
0x1000000000000000
So it generates a random number in the 2000…(66 bit) range, then iterates up to
7f000…(69 bit) and then I hit it with an if statement, that if it goes over 0x8000…to generate a new random starting point in the 0x2000…(66 bit) range and then rinse and repeat until key is found.

I am sure there are several ways to speed my old script up as well.

EDIT: I also use a file with the targets in it and use the Python set feature.

[WanderingPhilospher]

MoreForUs, here is my similar script. I wrote this probably 3 years ago when everyone was looking for #64, in old Python 2.7

Code:

import binascii, hashlib, base58, sys, ecdsa, codecs, random
pkeys = set(line.rstrip() for line in open('H160Targets.txt'))

lr    = 0x20000000000000000
ur    = 0x21000000000000000
br    = random.randrange(lr, ur)

def com(privkey):
    
    pvk_to_bytes = codecs.decode (privkey, 'hex')
    key = ecdsa.SigningKey.from_string (pvk_to_bytes, curve=ecdsa.SECP256k1).verifying_key
    key_bytes = key.to_string()
    key_hex = codecs.encode(key_bytes, 'hex')
    
    if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):
        public_key_compressed = '02' + key_hex[0:64]
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()
        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        if ripemd160_hex in pkeys:
            fwrite = open('KeyFound.txt', 'a')
            fwrite.write('Key: ' + privk + '  ' + ripemd160_hex + '\n' )
            
    else:
        public_key_compressed = '03' + key_hex[0:64]
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()
        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        if ripemd160_hex in pkeys:
            fwrite = open('KeyFound.txt', 'a')
            fwrite.write('Key: ' + privk + '  ' + ripemd160_hex + '\n' )

countall = 0
while True:

    if __name__== "__main__":

        privk = hex( br ).lstrip("0x").rstrip("L").zfill(64)
        com(privk)
        br = (br + 0x1000000000000000)
        sys.stdout.write("\r" + "   # of Keys: "  + str(countall))
        sys.stdout.flush()
        countall +=1
        if (br > 0x200000000000000000):
            lr    = 0x20000000000000000
            ur    = 0x21000000000000000
            br    = random.randrange(lr, ur)

As stated, I use a .txt file to store the h160 targets in and use the set function.

[digaran]

Code:

499218910101699464426468676555989843968 / 
 3808738022626491275226354038665694 =  131072

Code:

Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c 
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de

Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.

[WanderingPhilospher]

Code:

499218910101699464426468676555989843968 / 
 3808738022626491275226354038665694 =  131072

Code:

Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c 
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de

Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.

All I can see is that you ended up getting a BBC 👀

[nomachine]

reduce all of the additional hex keys i am searching for.

Code:

import os, random, secrets, hashlib, ecdsa

# List of target Hash 160 values to search for
target_public_key_hashes = [
    bytes.fromhex('20d45a6a762535700ce9e0b216e31994335db8a5'),
    bytes.fromhex('739437bb3dd6d1983e66629c5f08c70e52769371'),
    bytes.fromhex('e0b8a2baee1b77fc703455f39d51477451fc8cfc'),
    bytes.fromhex('61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'),
    bytes.fromhex('f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8'),
]
# Open a file for writing the found matches
with open('found_matches.txt', 'w') as output_file:
    while True:
        dec = secrets.SystemRandom().randrange(36893488147419103231, 2361183241434822606847)
        private_key_bytes = (b'\x00' * 32)[:-len(dec.to_bytes((dec.bit_length() + 7) // 8, 'big'))] + dec.to_bytes((dec.bit_length() + 7) // 8, 'big')
        signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
        h160 = hashlib.new('ripemd160', hashlib.sha256(signing_key.get_verifying_key().to_string("compressed")).digest()).digest()
        h160_hex = h160.hex()       
        if h160_hex.startswith(('20d45a', '739437', 'e0b8a2', '61eb8a', 'f6f543')):
            print(h160_hex, dec)
            if h160 in target_public_key_hashes:
                match_str = f"Found match with hash {dec}\n"
                print(match_str)
                output_file.write(match_str)
                target_public_key_hashes.remove(h160)  # Remove the found hash from the list
                if not target_public_key_hashes:
                    print("All target hashes found.")
                    break

There is no limit and way someone can search for a puzzle. It's like art. Mostly worthless art collection. 

[digaran]

Code:

499218910101699464426468676555989843968 / 
 3808738022626491275226354038665694 =  131072

Code:

Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c 
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de

Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.

All I can see is that you ended up getting a BBC 👀

That's because you are a pervert, I might add that I don't have the capacity for a big black... wait are we talking about the same thing? Lol  Well that BBC is your answer, but it seems nobody has figured it out yet. Good news for our dragon.😉

[Denis_Hitov]

subtract G 99 times from target, you will have 100 keys in total, then divide them all by 100, one of the results will definitely be the target/100. Then come here ask me what's next. But first I would need to test your script to see if it does what I said.😉

Hello, is this what you need?

Code:

import secp256k1 as ice
import bitcoin

target= "03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852"
print("Target:", target)
Target_upub= ice.pub2upub(target)

for i in range (100):
    A= ice.scalar_multiplication(i)
    B= ice.point_subtraction(Target_upub, A)
    C= ice.to_cpub(B.hex())
    D= bitcoin.divide(C, 100)

    data = open("S-1.txt","a")
    data.write(str(i)+" = "+str(C)+"\n")
    data.close()

    data = open("D-1.txt","a")
    data.write(str(i)+" = "+str(D)+"\n")
    data.close()

Hello.
Tell me how to remove this error?
PermissionError: [Errno 13] Permission denied:

No matter what I tried, it didn't work...

Code:

C:\BTCPazzle>test.py
Target: 0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b
Traceback (most recent call last):
  File "C:\BTCPazzle>test.py", line 20, in <module>
    data = open("D-1000.txt","a")
PermissionError: [Errno 13] Permission denied: "D-1000.txt" 

[digaran]

Hello.
Tell me how to remove this error?
PermissionError: [Errno 13] Permission denied:

No matter what I tried, it didn't work...

Code:

C:\BTCPazzle>test.py
Target: 0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b
Traceback (most recent call last):
  File "C:\BTCPazzle>test.py", line 20, in <module>
    data = open("D-1000.txt","a")
PermissionError: [Errno 13] Permission denied: "D-1000.txt" 

What did you try? Did you try running as administrator? Sometimes I used to get that error, I don't know the exact reason, because it wasn't always happening. It just returns that error because your system doesn't allow the script to open the text file, maybe change your directory?  Try like this if you are using windows, type in search box inside BTCPazzle folder, type cmd and hit enter, then type python test.py hit enter, this should fix it.

[WanderingPhilospher]

Well that BBC is your answer, but it seems nobody has figured it out yet. Good news for our dragon.

The answer to what? See, you throw out numbers and math but none of it makes sense, is new, or doesn't help in knowingly how to reduce a range.

Elaborate what is shows/tells you? If you can.

[Denis_Hitov]

What did you try? Did you try running as administrator? Sometimes I used to get that error, I don't know the exact reason, because it wasn't always happening. It just returns that error because your system doesn't allow the script to open the text file, maybe change your directory?  Try like this if you are using windows, type in search box inside BTCPazzle folder, type cmd and hit enter, then type python test.py hit enter, this should fix it.
[/quote]


I tried everything. I ran it with administrator rights and changed the directory. Useless.
Moreover, if you do not write the received data to a file, but simply display it on the screen, then the script works great.

[digaran]

Moreover, if you do not write the received data to a file, but simply display it on the screen, then the script works great.

Ok, try this one,

Code:

With open("S-1.txt","a") as file:
    file.write(str(i)+" = "+str(C)+"\n")
    file.close()

    With open("D-1.txt","a") as file:
    file.write(str(i)+" = "+str(D)+"\n")
    file.close()

If it didn't work, appeal to our future overlord aka AD(artificial dumbness).😉

[citb0in]

• Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
• Random mode

which program is that ? Can you link, please?

[vhh]

I think your comments/scripts confuse people more than helps them, IMO.

I thought everyone is a cryptography expert around here, or worked for more than 25 years on EC, if my methods confuses you is because you don't try working only with scalars to penetrate N the group order. If I explain everything step by step, where would be the fun in that? Have you shared anything you could discover by operating over scalars?
Whatever method, equation you can use to get definitive results over scalars, applies to points as well. I have explained how to get meaningful results based on that before. To Alek on a few previous pages, regarding how to get target /1024 for sure.

Digaran, you're like a toddler when it comes to ECC. Without the proper knowledge about ECC, group fields, etc , you will always be mesmerized by every result you're getting when you perform some arithmetical operations on the curve.

..if my methods confuses you is because you don't try working only with scalars to penetrate N the group order

That is so stupid in so many ways. The order is a prime number and you are trying to find a divisor that is different from 1 and the number itself....I'm speechless!

Whatever method, equation you can use to get definitive results over scalars, applies to points as well.

Another stupidity. For example you can multiply 2 scalars over the group field but you cannot do that with 2 points.


It seems that posting whatever crosses your mind, it's your full time job! This wouldn't be a problem if you will present concrete examples from A to Z or if you will have a solid understanding about ECC. The problem is that you're lacking both. There are tons of materials about ECC and how it works - you just have to google it. The more you'll learn, the more you'll realize what a masterpiece the secp256k1 is. "Penetrate N the group order" by using a combination of subtractions and divisions is at least pointless!

[nomachine]

If it didn't work, appeal to our future overlord aka AD(artificial dumbness).😉

ChatGTP is a dead horse for programming. I don't advise any normal person to do any serious things with it.
Doesn't see many things at once, you have to draw him exactly what you want, the possibility of it predicting what you want is small... Example.....

I tell him that I want to separate segments from the text file...

Segments are separated by a vertical line |

In file 1.txt :

text1 | text2 | text3| text4

I want to get in file 2.txt :

text1 | text2 | text4

From file 1.txt . . .

And tells me dead serious here is a python script for you:

Code:

import re

# Function to process the text and extract the desired parts
def extract_text(input_file, output_file):
    with open(input_file, 'r') as f:
        input_text = f.read()

    # Regular expression pattern to capture the desired text
    pattern = r'(\b\w+_\w+\b)\s*\|\s*(\b\w+_\w+\b)\s*\|\s*\w+\s*\|\s*(\b\w+_\w+\b)\s*\|'

    matches = re.findall(pattern, input_text)

    # Create the new text format from the extracted matches
    output_text = "\n".join([" | ".join(match) for match in matches])

    # Write the new text to the output file
    with open(output_file, 'w') as f:
        f.write(output_text)

# Example usage
input_file = '1.txt'
output_file = '2.txt'
extract_text(input_file, output_file)

The script does nothing....I have a blank file.

Too much dulls and overcomplicate it...

The solution is in bash one line

Code:

cat 1.txt | cut -d '|' -f1,2,4 > 2.txt

He says you are right,  sorry for the confusion….

p.s.
If someone thinks that this story has nothing to do with the topic - it does.

This is 1.txt file
https://raw.githubusercontent.com/HomelessPhD/BTC32/main/BTC32_solved_unsolved.txt

which program is that ? Can you link, please?

https://github.com/albertobsd/keyhunt

[kalos15btc]

I think your comments/scripts confuse people more than helps them, IMO.

I thought everyone is a cryptography expert around here, or worked for more than 25 years on EC, if my methods confuses you is because you don't try working only with scalars to penetrate N the group order. If I explain everything step by step, where would be the fun in that? Have you shared anything you could discover by operating over scalars?
Whatever method, equation you can use to get definitive results over scalars, applies to points as well. I have explained how to get meaningful results based on that before. To Alek on a few previous pages, regarding how to get target /1024 for sure.

Digaran, you're like a toddler when it comes to ECC. Without the proper knowledge about ECC, group fields, etc , you will always be mesmerized by every result you're getting when you perform some arithmetical operations on the curve.

..if my methods confuses you is because you don't try working only with scalars to penetrate N the group order

That is so stupid in so many ways. The order is a prime number and you are trying to find a divisor that is different from 1 and the number itself....I'm speechless!

Whatever method, equation you can use to get definitive results over scalars, applies to points as well.

Another stupidity. For example you can multiply 2 scalars over the group field but you cannot do that with 2 points.


It seems that posting whatever crosses your mind, it's your full time job! This wouldn't be a problem if you will present concrete examples from A to Z or if you will have a solid understanding about ECC. The problem is that you're lacking both. There are tons of materials about ECC and how it works - you just have to google it. The more you'll learn, the more you'll realize what a masterpiece the secp256k1 is. "Penetrate N the group order" by using a combination of subtractions and divisions is at least pointless!

I already told him, alert him, this user digran is talking nothing in this thread, he talk whatever came in his mind, with chatgpt, give us codes that he dsnt know how it work or whats the algorithm, he do actually create codes but with ai, just small chat, hi ai give me multiply 2 of 2 points, then he give us the codes,  60 pages in this thread with this user have nothing related to the subject of this thread, 60 pages with zero result only big talks and nothing,

Men . we are a lot of users who work in silent, if you have something that work please upload it in github, you dont have nothing keep your random search in vanity search or keyhunt please men let us think quite and understand other users, you are 24hours talking with maths you never understand ald algo, programing, even python if i came to you in real world and tell you to create anything stupid in python you will be lost, please STOP

DIGRAN STOP POSTING ON THIS POSTE,

Well that BBC is your answer, but it seems nobody has figured it out yet. Good news for our dragon.

The answer to what? See, you throw out numbers and math but none of it makes sense, is new, or doesn't help in knowingly how to reduce a range.

Elaborate what is shows/tells you? If you can.

YES Wandering, thats what i mean i just saw your reply now and im editing my reply, yes he never help with something everything is false non use have no sense you are not a programmer DIGRAN so please dont enter here to have the talk of the professional by the way i know you are talking a lot, you have a probleme im real life bro  you just have 4 stars in this forum that didint mean you are a pro or old in  btc community, stop this madness bro

I just got this idea, where is our code genius  @mcdouglasx, 😉 how about a script which subtracts G as many times as we want from target and divides

YES YOU ALWAYS HAVE AN IDEA THATS A BIG PROBLEME MEN we understand nothing from your maths and non sense codes you are doing nothing,
you want to substract ? https://github.com/WanderingPhilosopher/Windows-KeySubtractor
yes use keysubstractor this program is have all you can sub anypub key to whatever range you want, you cant substract pk to a know point because you already dont know the pk, there is no way here to do something to the puzzle you have tools just search please and never post anything here you are talking nothing here except this thread become big with your replys and non sense maths.


im asking the MODERATOR to mute The user DIGARAN.

[mcdouglasx]

The times of brute force are ending for some and already dead for others.
Mathematics is the only way, we have to be open to ideas even if they result in nothing, you don't need to get involved in ECC, you just need to solve the unknown,
target=?
and from that unknown by subtracting, adding, dividing or multiplying, there is a number that makes you know the real value of the target with the same formula in reverse.

Why do I think this has not been resolved yet?

It is not because the mathematics does not exist to do it, it is simply because of the computing power that limits us, but it would not be unreasonable to think that there is some shortcut in mathematics in which we do not depend on brute force, perhaps divisions with periodic results could be an interesting shortcut

[AlanJohnson]

YES YOU ALWAYS HAVE AN IDEA THATS A BIG PROBLEME MEN we understand nothing from your maths and non sense codes you are doing nothing,
you want to substract ? https://github.com/WanderingPhilosopher/Windows-KeySubtractor
yes use keysubstractor this program is have all you can sub anypub key to whatever range you want, you cant substract pk to a know point because you already dont know the pk, there is no way here to do something to the puzzle you have tools just search please and never post anything here you are talking nothing here except this thread become big with your replys and non sense maths.


im asking the MODERATOR to mute The user DIGARAN.

Maybe we should take it as a warning sign.  If you think too much about puzzles you can go mental

He is the first victim of bitcoin puzzle.

[digaran]

You want a quite  place to think and work?
You think you have seen off topic, spam?
You think someone is trolling, harassing forum members?
The third option is not a presidential order, is my suggestion, visit trust page and tag in red color.
@VHS/DVD/vhh, what is your academic background? Which university did you graduated from?
What is the UID of your main account? If you want answer, first respond to above questions, but I can tell you are one of the butthurt trolls.  I can tell because I never talked about multiplying two points(I only once said it's possible but never posted a script claiming it can do that).

@all of you whining kids, go find something which you can actually contribute to, all I see from you whiners, is whining.
@citb0in, 😂 you are still whining but silently with merits.
I don't know how else I put it, WHATEVER definitive results you can get when working with scalars, applies to points as  well. WHEN, you work with scalars, change the last digit from 1 to 9, see what changes in the results of division, divide by e.g, 256 and see what changes in the result, divide your target by 256, divide x2 of target by 256, divide half of target by 256, divide 1/16 of target by 256.

When you are done, go back to step 1, and this time change the last digit, do all the previous steps, rinse and repeat.
Or if you can't do that or don't understand how it could help you, stop hunting for puzzles.

[btc11235]

This puzzle is very strange. If it's for measuring the world's brute forcing capacity, 161-256 are just a waste (RIPEMD160 entropy is filled by 160, and by all of P2PKH Bitcoin). The puzzle creator could improve the puzzle's utility without bringing in any extra funds from outside - just spend 161-256 across to the unsolved portion 51-160, and roughly treble the puzzle's content density.

If on the other hand there's a pattern to find... well... that's awfully open-ended... can we have a hint or two?

I am the creator.

You are quite right, 161-256 are silly.  I honestly just did not think of this.  What is especially embarrassing, is this did not occur to me once, in two years.  By way of excuse, I was not really thinking much about the puzzle at all.

I will make up for two years of stupidity.  I will spend from 161-256 to the unsolved parts, as you suggest.  In addition, I intend to add further funds.  My aim is to boost the density by a factor of 10, from 0.001*length(key) to 0.01*length(key).  Probably in the next few weeks.  At any rate, when I next have an extended period of quiet and calm, to construct the new transaction carefully.

A few words about the puzzle.  There is no pattern.  It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty).  It is simply a crude measuring instrument, of the cracking strength of the community.

Finally, I wish to express appreciation of the efforts of all developers of new cracking tools and technology.  The "large bitcoin collider" is especially innovative and interesting!

Ok, so, I'm really hoping someone can help me out here...

I just learned about this puzzle a few weeks ago, and have since been writing scripts to try and find as much of the "pattern" used to generate these keys as possible, because I was convinced (mainly by this post at first) that there must've been a pattern, given the seemingly perfect incremental nature of the Log2 of each known private key (if you look at the whole number part, ignoring the decimal place)... And also, I think I was influenced by the fact that this is called a puzzle, and a puzzle is supposed to have, you know, clues and things that help you solve it, or at least a logic to it that is "figure-out-able"... But I digress...

Fast forward to yesterday, when I stumbled across the above post... If we assume this person is telling the truth, that they are "the creator" of this puzzle^[1], and that "there is no pattern", and that they simply used "a deterministic wallet" to generate "consecutive keys"... Well, then, I'm stumped...

I mean, first of all, what kind of wallet software can you use to "randomly" generate 256 keys that are all perfectly spaced apart, with Log2 values that just happen to be exactly incremental by one each...? Unless it's a total coincidence that, so far, all the solved keys just happen to have incremental Log2 values, and we'll eventually solve a key that doesn't...? (one which is either a duplicate of the previous one, or skips one whole number entirely, etc)

And then there's the fact that all of the hex values (as strings, minus the leading zeros) all appear to be grouped into groups of 4 by character length...? (e.g. the first 4 hexes are all 1 character long, the next 4 are all 2 characters long, etc...)

I mean, am I wrong that it doesn't seem to me like math with no pattern whatsoever would just happen to work-out that way? Are these "patterns" that I think I'm seeing really more coincidental (and not purposeful) as I imagine them to be? Or is this actually all an artifact of the cryptographic process and the math that powers Bitcoin...? That for Bitcoin to work properly, there is, in fact, some amount of pattern in the chaos?

I'm much more likely to believe that these keys were actually generated by a script (or some process of some sort) written/designed by the person who created this, and that even if they didn't intend for there to be a pattern, there is one^[2], and so maybe there's more to it that can still be discovered, to help lower the search space of each key even more that we already have... But maybe I only think that because I want there to be a way to solve a puzzle that doesn't actually contain any clues, or have any internal logic, and must simply be brute-forced, a feat that even the LBC has struggled to make very much progress towards...

So, help me out here, what do you think? Are these "patterns" that seem to be "clues" really either just coincidence, or artifacts of the formula and algorithms powering the system...? Or are they real patterns injected by the human who created this puzzle (intentionally or not), and could there be something else in the data that we just haven't noticed yet?

And maybe more importantly, what does a process for generating a puzzle like this even look like? Can you really ask a wallet software for 256 random but evenly spaced private keys, or would you have to script some amount of the process? I feel like if I can reverse engineer the creation process from the currently known data/results, it could help me figure-out if there's more to the pattern, or no pattern at all...



[1] A claim seemingly verified by the fact that the funds did actually move from the higher wallets to the lower unsolved wallets a few months later... Though of course that doesn't prove that they're the person who actually moved them, but then why would the real creator give this person credibility by doing for them what they promised us they'd do...?

[2] If only because people are known to be inherently bad at creating real randomness, and often inject patterns into things they make...