Bitcointalk Mobile Browser presented by IRLBTC™

<< >> (p.480)

Author

Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it (Read 323981 times)

stwenhao

Sr. Member

Offline

Activity: 358
Merit: 718

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 28, 2025, 07:10:23 PM

Merited by pbies (1)

#9581

Quote

How could this be reconstructed, if it is even possible?

By using the same deterministic wallet, with the same seed. There are many choices, but you can limit them to some extent, if you check, when the puzzle was created. Because if you have any HD wallet, which was created after January 2015, then you can reject it right away.

Also, you can quite quickly reject many wallets, just after checking some low keys. For example: the second private key can be equal to 2 or 3. In the original puzzle, it is equal to 3. Which means, that whatever method you will pick, if it gives you 2, then you can reject a given seed, so in this way, you can reject every second candidate seed, after testing only this thing.

And then, when you will have more and more seeds, giving you more and more matching puzzles for low keys, it should lead you in the right direction, if you picked the same HD wallet, as the creator did in 2015.

Another hint you can also use, is related to revealed public keys from puzzles in 161-256 range. In this case, the last 256th address contains 255 bits of entropy (because the first bit was masked with one). Which means, that you have only two possible cases for the original key, and it should match exactly, bit-by-bit.

I guess if you would know everything about the puzzle, except the creator's seed, then there would be only one matching solution, which would produce all 256 keys, exactly as in the puzzle. Because when it comes to needed entropy, you have 1 + 2 + ... + 255 bits of information, stored in the puzzle. You have 32,640 bits of information, produced out of some 128-bit, 256-bit, or maybe 512-bit seed.

I don't think the creator used more than 3,000 words in the original seed, to achieve multiple solutions. The only possible barriers could be related to collisions inside hash functions, but even in that case, grinding a single collision is one thing, but grinding 256 collisions, where everything matches exactly, is very unlikely.

So, after solving all 160 keys, there will still be a question (without any financial incentive) about private keys to everything in range 161-256 (which may be irrelevant in case of RIPEMD160 hashes, but if we would have pubkey-based puzzle, then it would still matter, just to check, how strong raw public keys are). And after solving all 256 keys, there will still be a huge question about the seed, which would connect everything together, and form an exact match for all 256 keys, when derived in a given way.

Quote

How would you create a puzzle if you were the creator?

First, I would create a new wallet, then generate 256 new keys, then extract private keys out of them, and then apply a bit-mask on each address, by using many leading zeroes, a final one-bit, and the rest bits from the wallet.

Which means, that the first generated key would be fully discarded (because it would always be simplified into private key equal to one), and the last key would begin with one-bit, and all other 255 bits would be taken out of it.

Proof of Work puzzle in mainnet and testnet4.

fixedpaul

Jr. Member

Offline

Activity: 51
Merit: 16

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 28, 2025, 10:15:54 PM

#9582

Quote from: kTimesG on April 28, 2025, 05:10:55 PM

All they'll get from this is that your grandfather was Einstein (the dice game observer). Now we need proofs.

I have curly hair and I hate quantum mechanics. Coincidence?

Virtuose

Jr. Member

Offline

Activity: 40
Merit: 1

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 28, 2025, 11:59:38 PM

#9583

Quote from: Bram24732 on April 28, 2025, 12:20:03 PM

Quote from: drpxxx on April 28, 2025, 12:09:11 PM

In your parallel_prefilter function, you still return immediately when the first chunk finds a solution
This means you lose the operations done by the other threads.

I'm not sure he does now, there's a shared variable incrementing. But the kicker is there :

Quote from: Virtuose on April 28, 2025, 11:55:53 AM

# Compute t2 for SHA256 prefilter if pubkey provided

Too bad we dont have public key in puzzle 69.
You're literally giving part of the solution of the search to your method

That was fun, but your code is obviously AI generated, and I'm not an LLM code fixer. So you're officially disqualified from the bounty.

That being said, with 99.5% improvement, I'm sur McD and WP will be thrilled to merge this method with the prefix one for even more gains. If they don't I might have to ask them to prove why it's not good Cheesy

It's not AI my friend, but Spyder IDE, https://www.spyder-ide.org/, but a lot of people are making up stories here ^^

Good luck

Benjade

Jr. Member

Online

Activity: 40
Merit: 1

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 12:57:44 AM

#9584

Quote from: Virtuose on April 28, 2025, 10:28:26 AM

Quote from: Bram24732 on April 28, 2025, 10:06:13 AM

Quote from: Virtuose on April 28, 2025, 09:54:59 AM

Um, no, I can't afford chatgpt and I only have a old desktop computer with 4 cpu ^^

ChatGPT is free to use on lower tiers which is more than enough to generate code.

Quote from: Virtuose on April 28, 2025, 09:54:59 AM

But if you could give me your linear in that case, share it and I'll show you, based on your code, that linear is crap in a box

You can simply update your own script doing something like this (Did not test it, but you should be able to understand the change required) :

Code:

# Decode address target to hex
ADDRESS_TARGET = b58decode(ADDRESS_TARGET)

# Compare with hex version of target instead of B58
def linear_scan(start: int, end: int, target: str):
   ops = 0
   for x in range(start, end+1):
   ops += 1
   if hash160_pubkey(x) == target:
   return x, ops
   return None, ops

That won't change anything, my friend. Are you sure you're coding it yourself? Maybe you're a chatgpt or a fiverr fan but I'm not. ^^
You can't compete with a c-bit prefilter for your linear.

Code:

#!/usr/bin/env python3
# coding: utf-8
"""
proof.py

Hash160 linear scan vs c-bit prefilter on puzzle 21.
Uses only hash160 comparisons and no Base58 encoding.
"""

import hashlib, math
from ecdsa import SECP256k1, util
from multiprocessing import Pool, cpu_count

# --- Configuration ---
ADDRESS_TARGET = "14oFNXucftsHiUMY8uctg6N487riuyXs4h"
HASH160_TARGET = "29a78213caa9eea824acf08022ab9dfc83414f56"
RANGE_HEX = "100000:1fffff"
FILTER_BITS = 2 # c ≥ 1 ⇒ >5% reduction
THRESHOLD = 5.0 # percent
# ---------------------

G = SECP256k1.generator
ORDER = SECP256k1.order
B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

# Base58Check decode to raw payload (1-byte version + 20-byte hash160)
def b58decode(s: str) -> bytes:
num = 0
for ch in s:
num = num*58 + B58.index(ch)
nbytes = (num.bit_length() + 7)//8
b = num.to_bytes(nbytes, 'big') if nbytes else b'\x00'
pad = len(s) - len(s.lstrip('1'))
full = b'\x00'*pad + b
payload, chk = full[:-4], full[-4:]
if hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4] != chk:
raise ValueError("Invalid Base58 checksum")
return payload

# Compute RIPEMD-160(SHA256(pubkey))
def hash160_pubkey(x: int) -> bytes:
P = x * G
prefix = b'\x02' if (P.y() & 1)==0 else b'\x03'
pub = prefix + util.number_to_string(P.x(), ORDER)
return hashlib.new('ripemd160', hashlib.sha256(pub).digest()).digest()

# Prepare target H160 bytes once
def get_target_h160() -> bytes:
if HASH160_TARGET:
return bytes.fromhex(HASH160_TARGET)
payload = b58decode(ADDRESS_TARGET)
return payload[1:]

# Simple linear scan comparing hash160 directly
def linear_scan(start: int, end: int, target_h: bytes):
ops = 0
for x in range(start, end+1):
ops += 1
if hash160_pubkey(x) == target_h:
return x, ops
return None, ops

# Worker for prefilter scan chunk
def prefilter_chunk(args):
idx, start, end, c, t1, target_h = args
for i, x in enumerate(range(start, end+1), start=1):
h2 = hash160_pubkey(x)
if (int.from_bytes(h2, 'big') >> (160-c)) != t1:
continue
if h2 == target_h:
return idx, i, x
return idx, None, None

# Parallel prefilter scan using hash160 comparisons
def parallel_prefilter(start: int, end: int, c: int, target_h: bytes, workers: int):
N = end - start + 1
chunk = math.ceil(N workers)
t1 = int.from_bytes(target_h, 'big') >> (160 - c)
args = [(i, start + i*chunk, min(start + (i+1)*chunk - 1, end), c, t1, target_h)
for i in range(workers)]
with Pool(workers) as p:
results = p.map(prefilter_chunk, args)
for idx, ops, x in sorted(results, key=lambda r: r[0]):
if ops:
return x, ops
return None, 0

# Main entry
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--workers", type=int, default=0,
help="number of processes (default = CPU count)")
args = parser.parse_args()

workers = args.workers or cpu_count()
s_hex, e_hex = RANGE_HEX.split(':')
start, end = int(s_hex, 16), int(e_hex, 16)
N = end - start + 1

print(f"Target address: {ADDRESS_TARGET}")
print(f"Range: 0x{s_hex} .. 0x{e_hex} (N = {N})")
print(f"Filter bits: {FILTER_BITS}, Processes: {workers}\n")

target_h = get_target_h160()

# Linear scan
print("→ Linear hash160 scan")
x_lin, ops_lin = linear_scan(start, end, target_h)
print(f" ✅ Found x = 0x{x_lin:x} in {ops_lin} H160 ops")

# Prefilter scan
print("\n→ Parallel prefilter scan")
x_pre, ops_pre = parallel_prefilter(start, end, FILTER_BITS, target_h, workers)
print(f" ✅ Found x = 0x{x_pre:x} in {ops_pre} heavy ops")

# Statistics
pct_lin = 100.0
pct_pre = ops_pre ops_lin * 100.0 if ops_lin else 0.0
reduction = pct_lin - pct_pre

print(f"\nPercent checks: hash160 = {pct_lin:.2f}%, prefilter = {pct_pre:.2f}%")
print(f"Reduction = {reduction:.2f}%")
print(("✅" if reduction>THRESHOLD else "⚠️") +
f" Reduction {'exceeds' if reduction>THRESHOLD else 'below'} {THRESHOLD}%")
winner = "Prefilter" if ops_pre < ops_lin else "Hash160"
print("🏆 Winner: " + winner + " scan")

if __name__ == "__main__":
main()

root:~# python3 proof.py
Target address: 14oFNXucftsHiUMY8uctg6N487riuyXs4h
Range: 0x100000 .. 0x1fffff (N = 1048576)
Filter bits: 2, Processes: 4

→ Linear hash160 scan
✅ Found x = 0x1ba534 in 763189 H160 ops

→ Parallel prefilter scan
✅ Found x = 0x1ba534 in 238901 heavy ops

Percent checks: hash160 = 100.00%, prefilter = 31.30%
Reduction = 68.70%
✅ Reduction exceeds 5.0%
🏆 Winner: Prefilter scan

I'm going to end up believing that you're just lucky Tongue

Wow, thats a really interesting approach. Ill probably include it in KeyQuest version 2 after running some feasibility tests, or maybe turn it into a standalone program. In any case, its promising If youre up for teaming up on it, that could be fun

https://github.com/Benjade/KeyQuest

kTimesG

Full Member

Offline

Activity: 546
Merit: 166

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 06:27:46 AM
Last edit: April 29, 2025, 06:42:23 AM by kTimesG

#9585

At this point, anyone who is too lazy to read fixedpaul's excellent explanation on how "math is broken" when jumping through a pre-fixed sequence of values, deserve their faith.

WanderingPhilospher: since you like to make experiments in order to believe stuff, here's one for you:

At every simulation, use a shared list of traversed positions, and send it to both methods.
You don't even need to build it in advance - simply start with an empty one.

- method A:
   - compute a new random position that isn't yet in the list
   - append position to shared list
   - check dataset[pos] as usual

- method B ("magic method"):
   - traverse list of positions, and do the prefix stuff just as you did as if you traversed a normal block or whatever.
   - when you skip: you skip remaining items from the shared list of positions
   - if the list has no more items: compute a new random (or not random, as it makes no difference) position that isn't yet in the list

OK. So now - we have nothing more than a "random pick" method that is being compared to a "random pick prefix" method, correct? Bare with me here. If I understand correctly, the prefix theory makes use of something called "proximity bias", so these two methods should have somewhat identical results, in terms of wins or anything else. Because the prefixes jump in some random order, right? And we also, uhm, only use random numbers everywhere now. Total identical conditions!

Now - I'm willing to bet an arm and a leg that the "same random order picks prefix method" will be like, a definitive winner.

However, I think everyone and their dog should know by now, that it is only a winner because it was compared with the "same random order method without prefix jumps".

As soon as you DARE to maybe choose another random order for either of the two methods, then it's gonna be obvious there are no advantages.

Ooops, I forgot - it's totally forbidden, because we are not doing the search in the same way. Well - now we do! Everyone knows this is how you're supposed to compare stuff, because, sure, the key might be at different random positions, and it's a total fallacy to ever compare something that starts from the end, with something that starts from the beginning. Doing that adds bias to the results, especially when doing lots of different simulations, all different! Duh...

Off the grid, training pigeons to broadcast signed messages.

Akito S. M. Hosana

Jr. Member

Offline

Activity: 364
Merit: 8

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 08:02:20 AM

#9586

Quote from: kTimesG on April 29, 2025, 06:27:46 AM

Now - I'm willing to bet an arm and a leg that the "same random order picks prefix method" will be like, a definitive winner.

This is all nonsense. No one is going to get rich here by taking a shortcut. Undecided

Bram24732

Member

Offline

Activity: 154
Merit: 15

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 09:20:54 AM

#9587

Quote from: Akito S. M. Hosana on April 29, 2025, 08:02:20 AM

Quote from: kTimesG on April 29, 2025, 06:27:46 AM

Now - I'm willing to bet an arm and a leg that the "same random order picks prefix method" will be like, a definitive winner.

This is all nonsense. No one is going to get rich here by taking a shortcut. Undecided

Tell you did not understand the post without telling me you didnt understand the post Cheesy

user_not_here

Jr. Member

Offline

Activity: 44
Merit: 2

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 10:23:57 AM

#9588

Quote from: Benjade on April 29, 2025, 12:57:44 AM

Quote from: Virtuose on April 28, 2025, 10:28:26 AM

Quote from: Bram24732 on April 28, 2025, 10:06:13 AM

Quote from: Virtuose on April 28, 2025, 09:54:59 AM

Um, no, I can't afford chatgpt and I only have a old desktop computer with 4 cpu ^^

ChatGPT is free to use on lower tiers which is more than enough to generate code.

Quote from: Virtuose on April 28, 2025, 09:54:59 AM

But if you could give me your linear in that case, share it and I'll show you, based on your code, that linear is crap in a box

You can simply update your own script doing something like this (Did not test it, but you should be able to understand the change required) :

Code:

That won't change anything, my friend. Are you sure you're coding it yourself? Maybe you're a chatgpt or a fiverr fan but I'm not. ^^
You can't compete with a c-bit prefilter for your linear.

Code:

https://github.com/Benjade/KeyQuest

KeyQuest is messy with animations.
On ubuntu 24 i got only flashing screen, win10 totally broken.
Why not just simple console print?

Virtuose

Jr. Member

Offline

Activity: 40
Merit: 1

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 11:03:42 AM

#9589

Quote from: Bram24732 on April 29, 2025, 09:20:54 AM

Quote from: Akito S. M. Hosana on April 29, 2025, 08:02:20 AM

Quote from: kTimesG on April 29, 2025, 06:27:46 AM

Now - I'm willing to bet an arm and a leg that the "same random order picks prefix method" will be like, a definitive winner.

This is all nonsense. No one is going to get rich here by taking a shortcut. Undecided

Tell you did not understand the post without telling me you didnt understand the post Cheesy

That's rather pretentious coming from someone in bad faith who doesn't know how to read code. Cheesy

Benjade

Jr. Member

Online

Activity: 40
Merit: 1

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 11:59:00 AM

#9590

Quote from: user_not_here on April 29, 2025, 10:23:57 AM

Quote from: Benjade on April 29, 2025, 12:57:44 AM

Quote from: Virtuose on April 28, 2025, 10:28:26 AM

Quote from: Bram24732 on April 28, 2025, 10:06:13 AM

Quote from: Virtuose on April 28, 2025, 09:54:59 AM

Um, no, I can't afford chatgpt and I only have a old desktop computer with 4 cpu ^^

ChatGPT is free to use on lower tiers which is more than enough to generate code.

Quote from: Virtuose on April 28, 2025, 09:54:59 AM

But if you could give me your linear in that case, share it and I'll show you, based on your code, that linear is crap in a box

You can simply update your own script doing something like this (Did not test it, but you should be able to understand the change required) :

Code:

That won't change anything, my friend. Are you sure you're coding it yourself? Maybe you're a chatgpt or a fiverr fan but I'm not. ^^
You can't compete with a c-bit prefilter for your linear.

Code:

https://github.com/Benjade/KeyQuest

KeyQuest is messy with animations.
On ubuntu 24 i got only flashing screen, win10 totally broken.
Why not just simple console print?

Because I like vintage design lol
More seriously, I would do something simpler for V2 soon or both I don't know.

Bram24732

Member

Offline

Activity: 154
Merit: 15

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 01:26:28 PM

#9591

Quote from: Virtuose on April 29, 2025, 11:03:42 AM

Quote from: Bram24732 on April 29, 2025, 09:20:54 AM

Quote from: Akito S. M. Hosana on April 29, 2025, 08:02:20 AM

Quote from: kTimesG on April 29, 2025, 06:27:46 AM

Now - I'm willing to bet an arm and a leg that the "same random order picks prefix method" will be like, a definitive winner.

This is all nonsense. No one is going to get rich here by taking a shortcut. Undecided

Tell you did not understand the post without telling me you didnt understand the post Cheesy

That's rather pretentious coming from someone in bad faith who doesn't know how to read code. Cheesy

A bit of irony

denyAKA BLACKANGEL

Newbie

Offline

Activity: 14
Merit: 1

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 05:53:54 PM

#9592

I finally found how the puzzle was made. I searched the internet for mathematical methods, and there are many, I haven't tested them all yet. I thought maybe someone has a better idea. But I think this hypothesis can work. I haven't finished everything yet. But I can only show one part. Maybe someone has a better idea. I think the creator used mersenne prime numbers (514 = 2 × 257)
bitwise test key = previous_key << n + k ( 21 = 8 << 1 + 5)
arithmetic sequences 3 → 7 → 8 → 21 deltas +4, +1, +13) I wrote more code with the help of AI of course because it can find every error in the code faster and also information. But my idea is that the creator used raylicite methods for every 3 or 5 or 8 address. I haven't tested everything yet. But I want to share it with you. Maybe someone has an idea. But definitely more brains, more ideas and success. one thing is certain that the addresses are generated with some patterns, I have the method for the first 10 addresses,i am currently writing the code for the rest.

ps..
please write your opinion, i m very interested.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Apr 29 16:24:01 2025

@author: blackangel
"""

import hashlib
from coincurve import PrivateKey

# Known solved private keys (puzzle_number: hex_private_key)
SOLVED_KEYS = {
   1: '0000000000000000000000000000000000000000000000000000000000000001',
   2: '0000000000000000000000000000000000000000000000000000000000000003',
   3: '0000000000000000000000000000000000000000000000000000000000000007',
   4: '0000000000000000000000000000000000000000000000000000000000000008',
   5: '0000000000000000000000000000000000000000000000000000000000000015',
   #6: '0000000000000000000000000000000000000000000000000000000000000031',
   7: '000000000000000000000000000000000000000000000000000000000000004c',
   #8: '00000000000000000000000000000000000000000000000000000000000000e0',
   #9: '00000000000000000000000000000000000000000000000000000000000001d3',
   #10: '0000000000000000000000000000000000000000000000000000000000000202',
   11: '0000000000000000000000000000000000000000000000000000000000000483',
   #12: '0000000000000000000000000000000000000000000000000000000000000a7b',
   13: '0000000000000000000000000000000000000000000000000000000000001460',
   #14: '0000000000000000000000000000000000000000000000000000000000002930',
   15: '00000000000000000000000000000000000000000000000000000000000068f3',
   16: '000000000000000000000000000000000000000000000000000000000000c936',
   17: '000000000000000000000000000000000000000000000000000000000001764f',
   18: '000000000000000000000000000000000000000000000000000000000003080d',
   19: '000000000000000000000000000000000000000000000000000000000005749f',
   20: '00000000000000000000000000000000000000000000000000000000000d2c55',

}

# -------------------------------------------------------------------------------
# Hypothesis 1: Mersenne-like numbers (2^n - 1)
# -------------------------------------------------------------------------------
def test_mersenne_hypothesis():
   print("\nHypothesis 1: Mersenne numbers (2^n - 1)")
   matches = 0
   for puzzle_number in SOLVED_KEYS:
   expected_key = (2 ** puzzle_number) - 1
   expected_hex = format(expected_key, '064x')
   actual_hex = SOLVED_KEYS[puzzle_number]
   if expected_hex == actual_hex:
   matches += 1
   print(f" Puzzle {puzzle_number}: MATCH (Expected {expected_hex})")
   else:
   print(f" Puzzle {puzzle_number}: FAIL (Expected {expected_hex}, Actual {actual_hex})")
   print(f"Matches: {matches}/{len(SOLVED_KEYS)}")

# -------------------------------------------------------------------------------
# Hypothesis 2: Hash-based generation (SHA-256 of puzzle number)
# -------------------------------------------------------------------------------
def test_hash_hypothesis():
   print("\nHypothesis 2: SHA-256 of puzzle number")
   matches = 0
   for puzzle_number in SOLVED_KEYS:
   #compute SHA-256 of puzzle number ( "5" -> hash)
   data = str(puzzle_number).encode()
   hash_hex = hashlib.sha256(data).hexdigest()

   # Truncate to 64 hex chars (32 bytes) to match private key format
   expected_hex = hash_hex[:64]
   actual_hex = SOLVED_KEYS[puzzle_number]

   if expected_hex == actual_hex:
   matches += 1
   print(f" Puzzle {puzzle_number}: MATCH (Hash {hash_hex})")
   else:
   print(f" Puzzle {puzzle_number}: FAIL (Hash {hash_hex}, Actual {actual_hex})")
   print(f"Matches: {matches}/{len(SOLVED_KEYS)}")

# -------------------------------------------------------------------------------
# Hypothesis 3: Bitwise shift with increment
# -------------------------------------------------------------------------------
def test_bitwise_hypothesis():
   print("\nHypothesis 3: Bitwise shift + increment")
   matches = 0
   prev_key = 0
   for puzzle_number in sorted(SOLVED_KEYS.keys()):
   actual_key = int(SOLVED_KEYS[puzzle_number], 16)
   if puzzle_number == 1:
   expected_key = 1
   else:
   expected_key = (prev_key << 1) + 1 # e.g., 1 -> 3 (0b11), 3 -> 7 (0b111)

   if expected_key == actual_key:
   matches += 1
   print(f" Puzzle {puzzle_number}: MATCH (Expected {hex(expected_key)})")
   else:
   print(f" Puzzle {puzzle_number}: FAIL (Expected {hex(expected_key)}, Actual {hex(actual_key)})")
   prev_key = actual_key
   print(f"Matches: {matches}/{len(SOLVED_KEYS)}")

# -------------------------------------------------------------------------------
# Hypothesis 4: Address generation from private key (for verification)
# -------------------------------------------------------------------------------
def generate_address(private_key_hex):
   private_key = PrivateKey.from_hex(private_key_hex)
   public_key = private_key.public_key.format().hex()
   return public_key # Simplified for demonstration

# -------------------------------------------------------------------------------
# Main Execution
# -------------------------------------------------------------------------------
if __name__ == "__main__":
   print("Testing hypotheses for private key generation...")

   # Test Hypothesis 1: Mersenne numbers
   test_mersenne_hypothesis()

   # Test Hypothesis 2: Hash-based generation
   test_hash_hypothesis()

   # Test Hypothesis 3: Bitwise shift
   test_bitwise_hypothesis()

   # Example: Generate address for Puzzle 1's key
   puzzle_1_key = SOLVED_KEYS[1]
   print(f"\nExample: Address for Puzzle 1 (Public Key): {generate_address(puzzle_1_key)}")

%runfilehome/blackangel/untitled20.py --wdir
Testing hypotheses for private key generation...

Hypothesis 1: Mersenne numbers (2^n - 1)
  Puzzle 1: MATCH (Expected 0000000000000000000000000000000000000000000000000000000000000001)
  Puzzle 2: MATCH (Expected 0000000000000000000000000000000000000000000000000000000000000003)
  Puzzle 3: MATCH (Expected 0000000000000000000000000000000000000000000000000000000000000007)
  Puzzle 4: FAIL (Expected 000000000000000000000000000000000000000000000000000000000000000f, Actual 0000000000000000000000000000000000000000000000000000000000000008)
  Puzzle 5: FAIL (Expected 000000000000000000000000000000000000000000000000000000000000001f, Actual 0000000000000000000000000000000000000000000000000000000000000015)
  Puzzle 7: FAIL (Expected 000000000000000000000000000000000000000000000000000000000000007f, Actual 000000000000000000000000000000000000000000000000000000000000004c)
  Puzzle 11: FAIL (Expected 00000000000000000000000000000000000000000000000000000000000007ff, Actual 0000000000000000000000000000000000000000000000000000000000000483)
  Puzzle 13: FAIL (Expected 0000000000000000000000000000000000000000000000000000000000001fff, Actual 0000000000000000000000000000000000000000000000000000000000001460)
  Puzzle 15: FAIL (Expected 0000000000000000000000000000000000000000000000000000000000007fff, Actual 00000000000000000000000000000000000000000000000000000000000068f3)
  Puzzle 16: FAIL (Expected 000000000000000000000000000000000000000000000000000000000000ffff, Actual 000000000000000000000000000000000000000000000000000000000000c936)
  Puzzle 17: FAIL (Expected 000000000000000000000000000000000000000000000000000000000001ffff, Actual 000000000000000000000000000000000000000000000000000000000001764f)
  Puzzle 18: FAIL (Expected 000000000000000000000000000000000000000000000000000000000003ffff, Actual 000000000000000000000000000000000000000000000000000000000003080d)
  Puzzle 19: FAIL (Expected 000000000000000000000000000000000000000000000000000000000007ffff, Actual 000000000000000000000000000000000000000000000000000000000005749f)
  Puzzle 20: FAIL (Expected 00000000000000000000000000000000000000000000000000000000000fffff, Actual 00000000000000000000000000000000000000000000000000000000000d2c55)
Matches: 3/14

Hypothesis 2: SHA-256 of puzzle number
  Puzzle 1: FAIL (Hash 6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b, Actual 0000000000000000000000000000000000000000000000000000000000000001)
  Puzzle 2: FAIL (Hash d4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35, Actual 0000000000000000000000000000000000000000000000000000000000000003)
  Puzzle 3: FAIL (Hash 4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce, Actual 0000000000000000000000000000000000000000000000000000000000000007)
  Puzzle 4: FAIL (Hash 4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a, Actual 0000000000000000000000000000000000000000000000000000000000000008)
  Puzzle 5: FAIL (Hash ef2d127de37b942baad06145e54b0c619a1f22327b2ebbcfbec78f5564afe39d, Actual 0000000000000000000000000000000000000000000000000000000000000015)
  Puzzle 7: FAIL (Hash 7902699be42c8a8e46fbbb4501726517e86b22c56a189f7625a6da49081b2451, Actual 000000000000000000000000000000000000000000000000000000000000004c)
  Puzzle 11: FAIL (Hash 4fc82b26aecb47d2868c4efbe3581732a3e7cbcc6c2efb32062c08170a05eeb8, Actual 0000000000000000000000000000000000000000000000000000000000000483)
  Puzzle 13: FAIL (Hash 3fdba35f04dc8c462986c992bcf875546257113072a909c162f7e470e581e278, Actual 0000000000000000000000000000000000000000000000000000000000001460)
  Puzzle 15: FAIL (Hash e629fa6598d732768f7c726b4b621285f9c3b85303900aa912017db7617d8bdb, Actual 00000000000000000000000000000000000000000000000000000000000068f3)
  Puzzle 16: FAIL (Hash b17ef6d19c7a5b1ee83b907c595526dcb1eb06db8227d650d5dda0a9f4ce8cd9, Actual 000000000000000000000000000000000000000000000000000000000000c936)
  Puzzle 17: FAIL (Hash 4523540f1504cd17100c4835e85b7eefd49911580f8efff0599a8f283be6b9e3, Actual 000000000000000000000000000000000000000000000000000000000001764f)
  Puzzle 18: FAIL (Hash 4ec9599fc203d176a301536c2e091a19bc852759b255bd6818810a42c5fed14a, Actual 000000000000000000000000000000000000000000000000000000000003080d)
  Puzzle 19: FAIL (Hash 9400f1b21cb527d7fa3d3eabba93557a18ebe7a2ca4e471cfe5e4c5b4ca7f767, Actual 000000000000000000000000000000000000000000000000000000000005749f)
  Puzzle 20: FAIL (Hash f5ca38f748a1d6eaf726b8a42fb575c3c71f1864a8143301782de13da2d9202b, Actual 00000000000000000000000000000000000000000000000000000000000d2c55)
Matches: 0/14

Hypothesis 3: Bitwise shift + increment
  Puzzle 1: MATCH (Expected 0x1)
  Puzzle 2: MATCH (Expected 0x3)
  Puzzle 3: MATCH (Expected 0x7)
  Puzzle 4: FAIL (Expected 0xf, Actual 0x8)
  Puzzle 5: FAIL (Expected 0x11, Actual 0x15)
  Puzzle 7: FAIL (Expected 0x2b, Actual 0x4c)
  Puzzle 11: FAIL (Expected 0x99, Actual 0x483)
  Puzzle 13: FAIL (Expected 0x907, Actual 0x1460)
  Puzzle 15: FAIL (Expected 0x28c1, Actual 0x68f3)
  Puzzle 16: FAIL (Expected 0xd1e7, Actual 0xc936)
  Puzzle 17: FAIL (Expected 0x1926d, Actual 0x1764f)
  Puzzle 18: FAIL (Expected 0x2ec9f, Actual 0x3080d)
  Puzzle 19: FAIL (Expected 0x6101b, Actual 0x5749f)
  Puzzle 20: FAIL (Expected 0xae93f, Actual 0xd2c55)
Matches: 3/14

Example: Address for Puzzle 1 (Public Key): 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

nomachine

Full Member

Offline

Activity: 714
Merit: 110

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 06:15:38 PM

#9593

Quote from: denyAKA BLACKANGEL on April 29, 2025, 05:53:54 PM

please write your opinion, i m very interested.

You can't imagine what I've tried in the last six years.
I even went back in time, generating numbers from 2015every second of that year.
From my archive of useless scripts:

Code:

import random
from datetime import datetime, timedelta

# List of target Puzzle, each corresponding to a range
target_numbers = [
(1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
(11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
(17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
(22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
(26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
(30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
(34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
(38, 146971536592), (39, 323724968937), (40, 1003651412950),
(41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
(44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
(47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
(50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
(53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
(56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
(59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
(62, 3908372542507822062), (63, 8993229949524469768),
(64, 17799667357578236628), (65, 30568377312064202855)
]

# Sort the target_numbers list by the first element of each tuple (the range start)
target_numbers.sort(key=lambda x: x[0])

# Specify the start and end date and times for the search
start_datetime_pre = datetime(2015, 1, 1, 0, 0, 0)
end_datetime_pre = datetime(2015, 1, 15, 19, 7, 14)
current_datetime = start_datetime_pre
time_step = timedelta(seconds=1)

# Initialize a set to keep track of found target numbers
found_targets = set()

# Function to find the seed for a single target number
def find_seed_for_target(target_num, current_time):
num, target_number = target_num
min_number = 2 ** (num - 1)
max_number = (2 ** num) - 1

low_seed = int(current_time.timestamp())
high_seed = int(end_datetime_pre.timestamp())

found_seed = None

while low_seed <= high_seed:
mid_seed = (low_seed + high_seed)/ 2

random.seed(mid_seed)
generated_number = random.randint(min_number, max_number)

if generated_number == target_number:
found_seed = mid_seed
break
elif generated_number < target_number:
low_seed = mid_seed + 1
else:
high_seed = mid_seed - 1

return found_seed

# Iterate through the time range
while current_datetime <= end_datetime_pre:
# Find seeds for all target numbers
found_seeds = [find_seed_for_target(target, current_datetime) for target in target_numbers]

# Print the results for each target number if found and not already printed
for i, (num, target_number) in enumerate(target_numbers, start=1):
if found_seeds[i - 1] is not None and target_number not in found_targets:
linuxtime = found_seeds[i - 1]
timestamp = datetime.fromtimestamp(linuxtime)
formatted_time = timestamp.strftime('%Y-%m-%d %H:%M:%S')
print(f"Puzzle {i} : Private Key : {target_number} | Timestamp: {formatted_time}")
found_targets.add(target_number)

# Move to the next second
current_datetime += time_step

Puzzle 1 : Private Key : 1 | Timestamp: 2015-01-08 09:33:37
Puzzle 2 : Private Key : 3 | Timestamp: 2015-01-12 02:20:26
Puzzle 3 : Private Key : 7 | Timestamp: 2015-01-12 02:20:26
Puzzle 4 : Private Key : 8 | Timestamp: 2015-01-01 05:32:54
Puzzle 5 : Private Key : 21 | Timestamp: 2015-01-10 05:57:01
Puzzle 10 : Private Key : 514 | Timestamp: 2015-01-01 02:46:31
Puzzle 6 : Private Key : 49 | Timestamp: 2015-01-04 16:08:31
Puzzle 7 : Private Key : 76 | Timestamp: 2015-01-01 00:26:36
Puzzle 12 : Private Key : 2683 | Timestamp: 2015-01-01 22:35:35
Puzzle 9 : Private Key : 467 | Timestamp: 2015-01-12 01:35:26
Puzzle 11 : Private Key : 1155 | Timestamp: 2015-01-05 14:58:56
Puzzle 8 : Private Key : 224 | Timestamp: 2015-01-13 00:32:15
Puzzle 13 : Private Key : 5216 | Timestamp: 2015-01-01 23:52:16
Puzzle 14 : Private Key : 10544 | Timestamp: 2015-01-05 03:59:22
Puzzle 16 : Private Key : 51510 | Timestamp: 2015-01-04 16:54:18
Puzzle 17 : Private Key : 95823 | Timestamp: 2015-01-02 16:43:39
Puzzle 15 : Private Key : 26867 | Timestamp: 2015-01-02 13:47:12
Puzzle 22 : Private Key : 3007503 | Timestamp: 2015-01-08 15:41:51

BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8

denyAKA BLACKANGEL

Newbie

Offline

Activity: 14
Merit: 1

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 06:31:21 PM

#9594

Quote from: nomachine on April 29, 2025, 06:15:38 PM

Quote from: denyAKA BLACKANGEL on April 29, 2025, 05:53:54 PM

please write your opinion, i m very interested.

You can't imagine what I've tried in the last six years.
I even went back in time, generating numbers from 2015every second of that year.
From my archive of useless scripts:

Code:

can i use you code i mean rewrite or improve ?

nomachine

Full Member

Offline

Activity: 714
Merit: 110

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 06:36:21 PM

#9595

Quote from: denyAKA BLACKANGEL on April 29, 2025, 06:31:21 PM

can i use you code i mean rewrite or improve ?

Of course, you can.

BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8

viceversas

Newbie

Offline

Activity: 8
Merit: 0

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 07:24:00 PM

#9596

Quote from: nomachine on April 29, 2025, 06:15:38 PM

Quote from: denyAKA BLACKANGEL on April 29, 2025, 05:53:54 PM

please write your opinion, i m very interested.

You can't imagine what I've tried in the last six years.
I even went back in time, generating numbers from 2015every second of that year.
From my archive of useless scripts:

Code:

this looks like a script for randstorm, cmiiw

nomachine

Full Member

Offline

Activity: 714
Merit: 110

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 07:43:59 PM

#9597

Quote from: viceversas on April 29, 2025, 07:24:00 PM

this looks like a script for randstorm, cmiiw

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

https://bt.irlbtc.com/view/1306983.msg62954595#msg62954595

Who cares? (it's useless anyway) Grin

BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8

Akito S. M. Hosana

Jr. Member

Offline

Activity: 364
Merit: 8

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 07:57:40 PM

#9598

Quote from: nomachine on April 29, 2025, 07:43:59 PM

Quote from: viceversas on April 29, 2025, 07:24:00 PM

this looks like a script for randstorm, cmiiw

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

https://bt.irlbtc.com/view/1306983.msg62954595#msg62954595

Who cares? (it's useless anyway) Grin

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

denyAKA BLACKANGEL

Newbie

Offline

Activity: 14
Merit: 1

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 08:00:05 PM

#9599

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:

%runfilehome/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

Full Member

Offline

Activity: 714
Merit: 110

Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it

April 29, 2025, 08:12:15 PM

#9600

Quote from: Akito S. M. Hosana on April 29, 2025, 07:57:40 PM

Quote from: nomachine on April 29, 2025, 07:43:59 PM

Quote from: viceversas on April 29, 2025, 07:24:00 PM

this looks like a script for randstorm, cmiiw

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

https://bt.irlbtc.com/view/1306983.msg62954595#msg62954595

Who cares? (it's useless anyway) Grin

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

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. Grin

BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8

Pages: « 1 ... 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 [480] 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 ... 566 »

Page 479

Viewing Page: 480