Bitcoin puzzle transaction ~32 BTC prize to who solves it

[nomachine]

this looks like a script for randstorm, cmiiw

Or does the randstorm script look like mine because it existed before?

https://bitcointalk.org/index.php?topic=1306983.msg62954595#msg62954595


Who cares? (it's useless anyway)

[Akito S. M. Hosana]

this looks like a script for randstorm, cmiiw

Or does the randstorm script look like mine because it existed before?

https://bitcointalk.org/index.php?topic=1306983.msg62954595#msg62954595


Who cares? (it's useless anyway)

You were very close to guessing the puzzle 66 range there. Too bad you gave up.  

[denyAKA BLACKANGEL]

Your code is very good but it is brute forcing and what I am doing is not, my code generates private keys from 1 to 160 bits in a few seconds, for the first ten addresses I already have the code in a second I generate real private keys for all 10 of the puzzle.Maybe you have some ideas on how to improvise my code.

Code:

from collections import defaultdict

SOLVED_KEYS = {
    1: 1, 2: 3, 3: 7, 4: 8, 5: 21, 10: 514
}

def calculate_pattern_score(keys):
    score = 0
    patterns = {
        'mersenne': lambda k: all(x == (2**i - 1) for i, x in enumerate(k, start=1)),
        'bitwise': lambda k: all(k[i] == (k[i-1] << 1) + 1 for i in range(1, len(k))),
        'prime': lambda k: sum(is_prime(x) for x in k)
    }
    
    for name, check in patterns.items():
        if name == 'mersenne' and check(keys):
            score += 5
        elif name == 'bitwise' and check(keys):
            score += 3
        elif name == 'prime':
            score += min(check(keys), 2)
    return score

def find_cycles(max_cycle=10):
    cycle_scores = defaultdict(int)
    puzzles = sorted(SOLVED_KEYS.items())
    
    for cycle in range(2, max_cycle+1):
        groups = defaultdict(list)
        for idx, (pn, key) in enumerate(puzzles):
            groups[idx//cycle].append((pn, key))
        
        total_score = sum(
            calculate_pattern_score([k for _, k in group])
            for group in groups.values()
        )
        cycle_scores[cycle] = total_score

    best_cycle = max(cycle_scores, key=cycle_scores.get)
    return best_cycle, cycle_scores

def analyze_groups(cycle_length):
    groups = defaultdict(list)
    puzzles = sorted(SOLVED_KEYS.items())
    for idx, (pn, key) in enumerate(puzzles):
        group_id = idx // cycle_length
        groups[group_id].append((pn, key))
    
    print(f"\nCycle length: {cycle_length}")
    for group_id, group in groups.items():
        pns = [pn for pn, _ in group]
        keys = [key for _, key in group]
        print(f"Group {group_id+1} (Puzzles {pns}): Keys {keys}")

# Compare groups for cycle lengths 2 and 3
analyze_groups(2)
analyze_groups(3)

def is_prime(n):
    if n < 2: return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0: return False
    return True

# Run analysis
best_cycle, scores = find_cycles()
print(f"Most likely cycle length: {best_cycle}")
print("Cycle scores:", dict(scores))

Code:

%runfile /home/blackangel/untitled21.py --wdir

Cycle length: 2
Group 1 (Puzzles [1, 2]): Keys [1, 3]
Group 2 (Puzzles [3, 4]): Keys [7, 8]
Group 3 (Puzzles [5, 10]): Keys [21, 514]

Cycle length: 3
Group 1 (Puzzles [1, 2, 3]): Keys [1, 3, 7]
Group 2 (Puzzles [4, 5, 10]): Keys [8, 21, 514]
Most likely cycle length: 2
Cycle scores: {2: 10, 3: 10, 4: 2, 5: 5, 6: 2, 7: 2, 8: 2, 9: 2, 10: 2}

[nomachine]

this looks like a script for randstorm, cmiiw

Or does the randstorm script look like mine because it existed before?

https://bitcointalk.org/index.php?topic=1306983.msg62954595#msg62954595


Who cares? (it's useless anyway)

You were very close to guessing the puzzle 66 range there. Too bad you gave up.  

You need to guess three consecutive puzzles (for example puzzle 66, 67, 68 in the row) with the same seed to at least 11 decimal places in order to predict the next one.  I've never managed to do that with any method, existing or invented — and I even have a program for self-evolving seeds.

[Akito S. M. Hosana]

self-evolving seeds.

This is the first time I'm hearing that term. What does it mean—like a DNA chain or something?

[nomachine]

self-evolving seeds.

This is the first time I'm hearing that term. What does it mean—like a DNA chain or something?

The challenge here is automating the expansion of the prefix. Each time a valid seed is found, i take a portion of its bytes as the new constant prefix. The key steps are:

1. Iteratively build up the constant prefix.
2. For each iteration, search for a seed with the current prefix followed by random bytes that produces a dec starting with the target string.
3. Once found, expand the prefix by taking some bytes from the found seed.
4. Repeat until the target string's required length is matched or no progress is made.

For example

Code:

import random, os
puzzle = 65
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
for x in range(1000000000000):
 constant_prefix = b''
 prefix_length = len(constant_prefix)
 length = 9
 ending_length = length - prefix_length
 ending_bytes = os.urandom(ending_length)
 random_bytes = constant_prefix + ending_bytes
 random.seed(random_bytes)
 dec = random.randint(lower_range_limit, upper_range_limit)
 if str(dec).startswith("3056"):
  print(dec, random_bytes)
  break

Define the target decimal string as "30568377312064202855".
Start with an empty prefix.
Start with a target prefix length of 4 .
In each iteration:
Generate random seeds with current prefix + random bytes to make up total length (fixed to 9 bytes).
For each seed, set the random state and generate dec.
Check if dec starts with current target prefix.
If found, extract the seed bytes used.
Extend the constant prefix by taking additional bytes from the beginning of the seed.
Increase the target prefix length (e.g., add 2 digits each time if possible).
Repeat until target prefix reaches 10 digits or more, or no solution found.

So the first target is "3056", then "30568", then "305683", etc., up to at least 10 digits.

Then hit the next puzzle. Keep going in a loop till you land on the same seed for three of 'em.
Coming up with a script to automate that is a real pain to brainstorm..

[kTimesG]

I need academics to translate these hieroglyphics.

Bram: 0.1 BTC for cracking a 160-bit hash vs. RetiredCoder: 0.1 BTC, just out of boredom.

First of all, RC kinda acknowledged he messed up, and he only sent 0.01 anyway.

Second: finally, some actual progress! I encourage you 100% to send that ChatGPT academic paper for peer review. Honestly, I really REALLY want to see such a paper to be seen by people like Bernstein and guys of that calibre. I am literally dying of curiosity about their opinion, even though it's basically a certainty by now: even if God Almighty himself shows up and proves it's BS, it won't matter much for some. Because there's always the need for a higher and higher authority to take a shot, even though a 10 year old gets it by now.

Oh, also... was it easier to skip posts in this thread about why the theory was disproven like maybe 783 times in all possible ways (and then some), or easier to just have some AI cook up non-sense science pseudo knowledge thesis?

You've got more chances for the horoscope to match your daily mood than for the prefix method to have any advantages over any other of the other 100.000! possible ways in which you can traverse the range. You know, out of all those gazillion permutations, in only one of them you can ever think that an edge is seen (though not even that one actually exists, but whatever - I'm not gonna judge if workload comparison should be analyzed as a horse race gambling shit show). Otherwise, you need 100.000! different prefix methods. Too bad that none of them beat each other up! Maybe you can publish a paper on that to solve this mistery as well please?

[kTimesG]

Dunno why I can’t get to that level of maths, but I’m curious where RC admitted he messed up.

Just saw that he kicked your ass when you tried to step in.

I'm afraid you may confuse irony of a boring reality, with kicking ass.

[Bram24732]

I need academics to translate these hieroglyphics.
Bram: 0.1 BTC for cracking a 160-bit hash vs. RetiredCoder: 0.1 BTC, just out of boredom.

I realize I’m cheap, sorry

That being said, it should be an easy 10k if the prefix theory has any advantage. But strangely since I posted the bounty I either see chatGPT nonsense or “not worth the effort you won’t pay up”.
People were really happy to defend the theory for free on this thread but as soon as it needs a reality check outside of the script kiddies bubble it’s crickets.

[FrozenThroneGuy]

I need academics to translate these hieroglyphics.
Bram: 0.1 BTC for cracking a 160-bit hash vs. RetiredCoder: 0.1 BTC, just out of boredom.

I realize I’m cheap, sorry

That being said, it should be an easy 10k if the prefix theory has any advantage. But strangely since I posted the bounty I either see chatGPT nonsense or “not worth the effort you won’t pay up”.
People were really happy to defend the theory for free on this thread but as soon as it needs a reality check outside of the script kiddies bubble it’s crickets.

the theory is not valid, because partially matching hash160 are uniformly distributed over the entire key space and over a large range they will give (with 8 matching HEX standard) a uniform distribution of 1/4.3 billion keys. but in practice I have seen partially matching hash160 even after 500,000 hash160 from the previous one. the probability that by jumping over the range after a partial fall you missed the desired hash160 is minimal, but not equal to 0. so either a probabilistic approach or any complications of a full sequential search that reduce its speed.

[Benjade]

I need academics to translate these hieroglyphics.
Bram: 0.1 BTC for cracking a 160-bit hash vs. RetiredCoder: 0.1 BTC, just out of boredom.

I realize I’m cheap, sorry

That being said, it should be an easy 10k if the prefix theory has any advantage. But strangely since I posted the bounty I either see chatGPT nonsense or “not worth the effort you won’t pay up”.
People were really happy to defend the theory for free on this thread but as soon as it needs a reality check outside of the script kiddies bubble it’s crickets.

I have the foolproof solution for you, no chatgpt here:

Buy 20,000 GPUs, rent a space, and quickly find key 69 and later. Once done, mine Bitcoin and don't forget to send my commission!

Cheers ! 

[kTimesG]

Why should your theory and ktimesg’s even be taken seriously?

All I see is two dudes clinging to a sinking ship, while the prefix idea clearly has way more advantages—but of course you ‘math geniuses’ just dismiss that.

I'm not sure I understand what you mean. Personally, I don't have a theory at all.

What I do have is basic understanding of numbers and how they work, so when somebody's plain out defying basic logic and insists on a bunch of claims about something which always inevitably results in a total contradiction of how the numbers work, then, yes, there's a problem.

Call it the common sense theory if you want. Do you want some links to the Scooby Doo theories though? You can find some flavor of it that works better or at least the same than any prefix theory you may "feel" has broken the principles of reality.

[fixedpaul]

Attention!

Do you want to be the best mathematician?

Here's a new method to beat a sequential search that goes from 0 to N-1 !

It's called sequential-advanced, and it's based on solid mathematical and probabilistic theories. In fact, the probability that it does not find the key before the classic sequential method is 1/N — that's 1/2^68 if we look at puzzle 69, almost zero!!
This means that, compared to the classic sequential search, the advanced method will find the key first in 99.99999999% of cases! Incredible.

But let's put it to the test with a script

Code:

import hashlib
import random
import time

TOTAL_SIZE = 10000
SIMULATIONS = 500

def generate_h160(data):
    return hashlib.new('ripemd160', str(data).encode()).hexdigest()

def sequential(dataset, target_hash):
    checks = 0
    for i in range(len(dataset)):
        checks += 1
        if generate_h160(dataset[i]) == target_hash:
            return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def sequential_advanced(dataset, target_hash):
    checks = 0
    for i in range(1, len(dataset)):
        checks += 1
        if generate_h160(dataset[i]) == target_hash:
            return {"checks": checks, "found": True}
    checks += 1  # check 0 at the end
    if generate_h160(dataset[0]) == target_hash:
        return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def compare_methods():
    results = {
        "sequential": {"wins": 0, "total_checks": 0, "total_time": 0},
        "sequential_advanced": {"wins": 0, "total_checks": 0, "total_time": 0},
        "ties": 0
    }

    for i in range(SIMULATIONS):
        dataset = list(range(TOTAL_SIZE))
        random.shuffle(dataset)
        target = random.choice(dataset)
        target_hash = generate_h160(target)

        start = time.perf_counter()
        res_seq = sequential(dataset, target_hash)
        time_seq = time.perf_counter() - start

        start = time.perf_counter()
        res_adv = sequential_advanced(dataset, target_hash)
        time_adv = time.perf_counter() - start

        results["sequential"]["total_checks"] += res_seq["checks"]
        results["sequential_advanced"]["total_checks"] += res_adv["checks"]
        results["sequential"]["total_time"] += time_seq
        results["sequential_advanced"]["total_time"] += time_adv

        if res_seq["checks"] < res_adv["checks"]:
            results["sequential"]["wins"] += 1
        elif res_seq["checks"] > res_adv["checks"]:
            results["sequential_advanced"]["wins"] += 1
        else:
            results["ties"] += 1

        print(f"Simulation {i+1}: Sequential = {res_seq['checks']} checks in {time_seq:.6f}s | Sequential-Advanced = {res_adv['checks']} checks in {time_adv:.6f}s")

    # Calcolo medie
    avg_time_seq = results["sequential"]["total_time"] / results["sequential"]["wins"] if results["sequential"]["wins"] > 0 else float('inf')
    avg_time_adv = results["sequential_advanced"]["total_time"] / results["sequential_advanced"]["wins"] if results["sequential_advanced"]["wins"] > 0 else float('inf')
    avg_checks_seq = results["sequential"]["total_checks"] / results["sequential"]["wins"] if results["sequential"]["wins"] > 0 else float('inf')
    avg_checks_adv = results["sequential_advanced"]["total_checks"] / results["sequential_advanced"]["wins"] if results["sequential_advanced"]["wins"] > 0 else float('inf')

    print(f"""
=== FINAL RESULTS ===
Wins:
Sequential: {results['sequential']['wins']}
Sequential-Advanced: {results['sequential_advanced']['wins']}
Ties: {results['ties']}

Total Checks:
Sequential: {results['sequential']['total_checks']}
Sequential-Advanced: {results['sequential_advanced']['total_checks']}

Total Time:
Sequential: {results['sequential']['total_time']:.6f} seconds
Sequential-Advanced: {results['sequential_advanced']['total_time']:.6f} seconds

Averages (Total Time / Wins):
Sequential : {avg_time_seq:.6f} seconds/victory
Sequential-Advanced : {avg_time_adv:.6f} seconds/victory

Checks per Win:
Sequential : {avg_checks_seq:.2f} checks/win
Sequential-Advanced : {avg_checks_adv:.2f} checks/win
""")

if __name__ == '__main__':
    compare_methods()

Result:

Code:

=== FINAL RESULTS ===
Wins:
Sequential: 0
Sequential-Advanced: 500
Ties: 0

Total Checks:
Sequential: 2397028
Sequential-Advanced: 2396528

Total Time:
Sequential: 15.394807 seconds
Sequential-Advanced: 12.848593 seconds

Averages (Total Time / Wins):
Sequential : inf seconds/victory
Sequential-Advanced : 0.025697 seconds/victory

Checks per Win:
Sequential : inf checks/win
Sequential-Advanced : 4793.06 checks/win

Look at that! 500 to 0 — unbelievable, right? Never use the normal sequential search again.

And don’t use the prefix-method either, because against the original sequential approach, you might lose sometimes.
With this new method, instead, you’re practically unbeatable!

But how does it work?

Simple: the advanced method searches sequentially starting from 1 instead of 0, and it checks 0 only at the end.

Checkmate to the sequential method from 0 to N-1!
I've found a method that retires it — one that lets me find the key faster in 99.999999% of cases.

Right?

[kTimesG]

Attention!

Your post failed the common sense filter, thanks. And I'm not even a mathematician, nor wish to be one - that shit's too complicated. Also, now you have smth that has 100% win-rate, so use that please, ok?

[Bram24732]

Why should your theory and ktimesg’s even be taken seriously?
All I see is two dudes clinging to a sinking ship, while the prefix idea clearly has way more advantages—but of course you ‘math geniuses’ just dismiss that.

That's not a theory but basic math.

I'm litterally giving away 10k USD if you post the prefix idea to the cryptography subreddit and get it gets validated there. Yet no one does it, I wonder why.

[7xminer]

After reading a lot here, at least for me, I can see that the idea behind prefix analysis isn't going to work (sad, I was trying to come with something too). Because the X point is passed through SHA256 and RIPEMD160 and the hash result is very random. So no pattern can be found or a high probability that the key is on that range. If this kind of analysis were effective, why haven't people who solved "higher" puzzles continued to solve subsequent ones? Because it was solved with brute force and a lot of CPU/GPU power using pure brute force / BSGS / Kangaroo.

With puzzle 66, I was very close with a prefix I found. But I also found a lot of others prefixes. How do I know which one to follow? This is the main problem.

But, this is where the fun continues. I will continue to run my scripts. Maybe I'll win the lotto and find the solution. hehehehe!  

[bibilgin]

Basic Mathematics = I have heard this saying in many places.

It is a well-known idea that people who say this generally think verbally, and only apply things they have memorized.

Numerical thoughts are different. They like to examine the details of something. Many scientists are numerical.

"There is no point in telling someone who is color blind that green is red. Because the color he sees has to say it. Even if you tell him why, I see red." he says.

Those who see green and those who see red. lol

Edit;

I saw Bram was going to give $10,000. (Not convincing. Because he knows he can't prove it either. I would say higher. $50,000. lol)

Let's race. You, put the money in the low bit wallet. Let's have the same equipment. Who will find the money?

Greens? Reds? lol

69. The wallet has been solved. Congratulations to the winner. (I guess it's not Bram.)

Hex Code = 101D83275FB2BC7E0C

[nochkin]

People were really happy to defend the theory for free on this thread but as soon as it needs a reality check outside of the script kiddies bubble it’s crickets.

Clearly, crickets are the winners here.

[Bram24732]

You do it, otherwise shut up and leave. You, being the cryptographer here, go ahead, propose it and share it here.
So, start by making a formal post about your reward in the technical area, where ideas are not mixed with interactions from alts accounts.

Again, I have nothing to propose. I simply say prefix theory does not provide a statistical advantage. Some people disagree and say we don't understand the math.
No problem. Those people can have it validated by independent cryptographers and it's an easy 10k for them. The burden of the proof is on the person saying they have a better method, don't you think ?

everyone knows you have no intention of paying.

I'm not sure why you think that. It's public knowledge that I have the funds after 67 and 68.
I'd be glad to use any info about a better method for 69, so it has value to me either way.

[WanderingPhilospher]

69 has fallen!

0x0000000000000000000000000000000000000000000000101d83275fb2bc7e0c