Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Akito S. M. Hosana]

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. 

[Bram24732]

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. 

Tell you did not understand the post without telling me you didn’t understand the post

[Virtuose]

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. 

Tell you did not understand the post without telling me you didn’t understand the post

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

[Benjade]

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.

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 

Wow, that’s a really interesting approach. I’ll probably include it in KeyQuest version 2 after running some feasibility tests, or maybe turn it into a standalone program. In any case, it’s promising… If you’re up for teaming up on it, that could be fun 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]

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. 

Tell you did not understand the post without telling me you didn’t understand the post

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

A bit of irony

[denyAKA BLACKANGEL]

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)}")  




%runfile /home/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]

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 2015—every 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

[denyAKA BLACKANGEL]

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 2015—every 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

   

can i use you code i mean rewrite or improve ?

[nomachine]

can i use you code i mean rewrite or improve ?

Of course,  you can.

[viceversas]

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 2015—every 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

this looks like a script for randstorm, cmiiw

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