Goodbye, world!

[mcdouglasx]

In case anyone hasn't noticed, someone sent money to the riddle, the Pi Day.

https://mempool.space/tx/b5b5d9f0923627a84f4e303cda2ea0f8db9455ac938c4dfbda819725e3f76579?showDetails=true

[nutildah]

In case anyone hasn't noticed, someone sent money to the riddle, the Pi Day.

https://mempool.space/tx/b5b5d9f0923627a84f4e303cda2ea0f8db9455ac938c4dfbda819725e3f76579?showDetails=true

I spent a few hours doing different permutations of on-chain data, tested about 10,000 300k different combinations and came up with zilch. I'm not saying the puzzle isn't solvable, but if you really "think like nullius," then the puzzle would be too hard for anybody to solve with the given information, because nullius always insisted on being the smartest person in the room.

What's wrong with my setup? Probably something.

Code:

import hashlib
import hmac
from ecdsa import SigningKey, SECP256k1

def to_witness(pubkey: bytes) -> str:
    sha = hashlib.sha256(pubkey).digest()
    rip = hashlib.new('ripemd160', sha).digest()
    return rip.hexdigest()

# ==================== ON-CHAIN DATA ====================
TARGET = '5ab6db66fb0dd08ecb238f07141ffea56189552d'

TXID = bytes.fromhex('000000000fdf0c619cd8e0d512c7e2c0da5a5808e60f12f1e0d01522d2986a51')
OPR  = bytes.fromhex('f09f98bc2053616372696669636520746f204c61756461212028746f7069633d3532383239313129')
SIG  = bytes.fromhex('3044022053310e70c23aa279b05cad3527bac28727a4615b9872be4e748cd91a78e5d76c02207d740b8a6904c0d391296249c7773515d947ce8535fc20637c3eb8020eb79f1801')
PUB  = bytes.fromhex('0227eb9f073f99f26c8ce69b17aec1bcee7b414ff4bae5b1b3ab0a710b63da62cf')

PREV_OP_RETURN = bytes.fromhex('db4b57d9dd5779b04988bd4520de55f44f84d76fd7d594a6ea53f49bb8ce380e')

R = SIG[4:36]
S = SIG[38:70]
FULL = SIG + PUB

seeds = []

# 1. Raw values
seeds.extend([R, S, R + S, PREV_OP_RETURN, FULL])

# 2. Simple hashes
for data in [R, S, R + S, PREV_OP_RETURN, FULL]:
    seeds.append(hashlib.sha256(data).digest())
    seeds.append(hashlib.sha256(hashlib.sha256(data).digest()).digest())
    seeds.append(hashlib.sha512(data).digest()[:32])

# 3. Text mixes
text = b'Sacrifice to Lauda! (topic=5282911)'
for data in [R, S, PREV_OP_RETURN, R + S]:
    seeds.append(hashlib.sha256(text + data).digest())
    seeds.append(hashlib.sha512(text + data).digest()[:32])

# 4. HMAC with "Meow."
meow = b'Meow.'
for data in [TXID, OPR, PREV_OP_RETURN, R + S]:
    seeds.append(hmac.new(meow, data, hashlib.sha256).digest())

# 5. Matryoshka on R/S + previous OP_RETURN
for base in [R + S, R + PREV_OP_RETURN, S + PREV_OP_RETURN, R + S + PREV_OP_RETURN]:
    h = base
    for _ in range(10):
        seeds.append(h)
        h = hashlib.sha256(h).digest()

# 6. Nine lives
for base in [TXID[9:], R, S, PREV_OP_RETURN]:
    seeds.append(hashlib.sha256(base * 9).digest())

print(f"Testing {len(seeds)} candidates... (final comprehensive pure on-chain round)")

# ==================== TEST LOOP ====================
found = False
for i, seed in enumerate(seeds):
    if len(seed) != 32:
        seed = hashlib.sha256(seed).digest()[:32]

    priv_int = int.from_bytes(seed, 'big')
    if priv_int == 0 or priv_int >= SECP256k1.order:
        continue

    try:
        sk = SigningKey.from_string(seed, curve=SECP256k1)
        vk = sk.verifying_key
        prefix = b'\x02' if vk.to_string()[32] % 2 == 0 else b'\x03'
        compressed = prefix + vk.to_string()[:32]

        if to_witness(compressed) == TARGET:
            print(f"\n🎉🎉🎉 FOUND AT INDEX {i} ! 🎉🎉🎉")
            print(f"Private key (hex): {seed.hex()}")
            found = True
            break
    except:
        continue

if not found:
    print("\nNo match yet.")

[mcdouglasx]

What's wrong with my setup? Probably something.

I tried countless combinations, many hashes, xor operations, and more, and used all the data I could think of, and I had no luck. I don't know how he did it, but there is surely a very, very original logic in the construction of the private key.

Code:

import hashlib
import struct
import secp256k1 as ice
from itertools import permutations, product, cycle

REAL_PRIZE = "bc1qt2mdkehmphggajer3ur3g8l754scj4fdrmw3rn"
TEST_ADDRESS = "bc1q3rt3gwz4074cys54acuf32nkkug2ggygzzuzuk"

BECH32_CHARS = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'

def bech32_polymod(v):
    g = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
    chk = 1
    for x in v:
        b = chk >> 25
        chk = (chk & 0x1ffffff) << 5 ^ x
        for i in range(5):
            chk ^= g[i] if ((b >> i) & 1) else 0
    return chk

def bech32_hrp_expand(hrp):
    return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]

def bech32_create_checksum(hrp, data):
    v = bech32_hrp_expand(hrp) + data
    p = bech32_polymod(v + [0]*6) ^ 1
    return [(p >> 5 * (5 - i)) & 31 for i in range(6)]

def bech32_encode(hrp, data):
    combined = data + bech32_create_checksum(hrp, data)
    return hrp + '1' + ''.join([BECH32_CHARS[d] for d in combined])

def convertbits(data, frombits, tobits, pad=True):
    acc, bits = 0, 0
    ret = []
    maxv = (1 << tobits) - 1
    for value in data:
        acc = (acc << frombits) | value
        bits += frombits
        while bits >= tobits:
            bits -= tobits
            ret.append((acc >> bits) & maxv)
    if pad and bits:
        ret.append((acc << (tobits - bits)) & maxv)
    return ret

def generate_segwit_both(privkey_hex):
    addresses = {"compressed": None, "uncompressed": None}
    try:
        A1 = int(privkey_hex, 16)
        if A1 <= 0 or A1 >= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141:
            return addresses
        
        A0 = ice.scalar_multiplication(A1).hex()
        
        pubkey_c = ice.to_cpub(A0)
        sha_c = hashlib.sha256(bytes.fromhex(pubkey_c)).digest()
        h160_c = hashlib.new('ripemd160', sha_c).digest()
        data_c = convertbits(list(h160_c), 8, 5)
        addresses["compressed"] = bech32_encode('bc', [0] + data_c)
        
        pubkey_u = ice.to_pub(A0)
        sha_u = hashlib.sha256(bytes.fromhex(pubkey_u)).digest()
        h160_u = hashlib.new('ripemd160', sha_u).digest()
        data_u = convertbits(list(h160_u), 8, 5)
        addresses["uncompressed"] = bech32_encode('bc', [0] + data_u)
    except:
        pass
    return addresses

def get_byte_variants(line):
    variants = []
    clean = line.strip()
    if not clean:
        return variants

    variants.append((clean.encode('utf-8'), f"TXT({clean})"))

    if len(clean) % 2 == 0 and all(c in '0123456789abcdefABCDEF' for c in clean):
        try:
            raw_bytes = bytes.fromhex(clean)
            variants.append((raw_bytes, f"HEX_BE({clean})"))
            variants.append((raw_bytes[::-1], f"HEX_LE({clean})"))
        except:
            pass

    if clean.isdigit():
        try:
            val = int(clean)
            variants.append((struct.pack(">I", val), f"INT32_BE({val})"))
            variants.append((struct.pack("<I", val), f"INT32_LE({val})"))
            variants.append((struct.pack(">Q", val), f"INT64_BE({val})"))
            variants.append((struct.pack("<Q", val), f"INT64_LE({val})"))
        except:
            pass

    return variants

def xor_bytes(b1, b2):
    if not b1 or not b2:
        return b""
    if len(b1) < len(b2):
        b1, b2 = b2, b1
    return bytes(x ^ y for x, y in zip(b1, cycle(b2)))

def add_bytes_mod(b1, b2):
    if not b1 or not b2:
        return b""
    if len(b1) < len(b2):
        b1, b2 = b2, b1
    return bytes((x + y) % 256 for x, y in zip(b1, cycle(b2)))

def apply_hash_methods(seed_bytes):
    results = []
    
    results.append(("SHA256_Simple", hashlib.sha256(seed_bytes).hexdigest()))
    results.append(("SHA256_Double", hashlib.sha256(hashlib.sha256(seed_bytes).digest()).hexdigest()))
    
    curr = hashlib.sha256(seed_bytes).digest()
    for _ in range(8):
        curr = hashlib.sha256(curr).digest()
    results.append(("SHA256_9x", curr.hex()))
    
    sha = hashlib.sha256(seed_bytes).digest()
    results.append(("HASH160", hashlib.new('ripemd160', sha).digest().hex()))
    results.append(("RIPEMD160_Direct", hashlib.new('ripemd160', seed_bytes).digest().hex()))
    
    results.append(("SHA512", hashlib.sha512(seed_bytes).hexdigest()))
    results.append(("SHA3_256", hashlib.sha3_256(seed_bytes).hexdigest()))
    results.append(("BLAKE2b", hashlib.blake2b(seed_bytes, digest_size=32).hexdigest()))
    
    try:
        results.append(("SHA256_Upper", hashlib.sha256(seed_bytes.upper()).hexdigest()))
        results.append(("SHA256_Lower", hashlib.sha256(seed_bytes.lower()).hexdigest()))
    except:
        pass
        
    results.append(("SHA256_Salt_9lives", hashlib.sha256(seed_bytes + b"9lives").hexdigest()))
    results.append(("SHA256_Salt_kitty", hashlib.sha256(seed_bytes + b"kitty").hexdigest()))
    results.append(("HMAC_Lauda", hashlib.pbkdf2_hmac('sha256', seed_bytes, b'Lauda', 1).hex()))
    results.append(("HMAC_nullius", hashlib.pbkdf2_hmac('sha256', seed_bytes, b'nullius', 1).hex()))
    
    return results

def verify_final_key(privkey_hex, label_origin):
    addrs = generate_segwit_both(privkey_hex)
    for key_type, addr in addrs.items():
        if not addr:
            continue
        if addr == REAL_PRIZE:
            print(f"\n{'='*60}")
            print(f"!!! PRIZE FOUND !!! ({key_type.upper()})")
            print(f"Address: {addr}")
            print(f"Cryptographic Origin: {label_origin}")
            print(f"Final Private Key (Hex): {privkey_hex}")
            print(f"{'='*60}")
            return True
        elif addr == TEST_ADDRESS:
            print(f"\n[VERIFICATION] Test address found ({key_type.upper()})")
            print(f"  Logical path: {label_origin}")
            print(f"  Private Key: {privkey_hex}")
            print(f"  (Continuing search towards real target...)\n")
    return False

def main():
    try:
        with open("data.txt", "r", encoding="utf-8") as f:
            raw_lines = [l.strip() for l in f if l.strip()]
    except FileNotFoundError:
        print("Error: data.txt not found.")
        return

    print(f"Target: {REAL_PRIZE}")
    print(f"Lines loaded: {len(raw_lines)}")
    print("Pre-processing binary variants, logical operations (XOR) and modular arithmetic...\n")
    
    pool_variants = [get_byte_variants(line) for line in raw_lines]
    
    print("=== LEVEL 1: Individual Component Analysis ===")
    for idx, variants in enumerate(pool_variants):
        for b_data, desc in variants:
            if len(b_data) == 32:
                if verify_final_key(b_data.hex(), desc):
                    return
            for hash_name, hash_hex in apply_hash_methods(b_data):
                if verify_final_key(hash_hex, f"{desc} -> {hash_name}"):
                    return

    print("\n=== LEVEL 2: Combinations and Combined Operations (XOR / ADD / CONCAT) ===")
    for idx1, idx2 in permutations(range(len(pool_variants)), 2):
        for (b1, desc1), (b2, desc2) in product(pool_variants[idx1], pool_variants[idx2]):
            
            b_concat = b1 + b2
            desc_concat = f"[{desc1} + {desc2}]"
            if len(b_concat) == 32 and verify_final_key(b_concat.hex(), desc_concat): return
            for h_name, h_hex in apply_hash_methods(b_concat):
                if verify_final_key(h_hex, f"{desc_concat} -> {h_name}"): return
            
            b_xor = xor_bytes(b1, b2)
            desc_xor = f"[{desc1} XOR {desc2}]"
            if len(b_xor) == 32 and verify_final_key(b_xor.hex(), desc_xor): return
            for h_name, h_hex in apply_hash_methods(b_xor):
                if verify_final_key(h_hex, f"{desc_xor} -> {h_name}"): return

            b_add = add_bytes_mod(b1, b2)
            desc_add = f"[{desc1} +mod {desc2}]"
            if len(b_add) == 32 and verify_final_key(b_add.hex(), desc_add): return
            for h_name, h_hex in apply_hash_methods(b_add):
                if verify_final_key(h_hex, f"{desc_add} -> {h_name}"): return

    print("\n=== LEVEL 3: Multi-level Combinations (Concat & XOR) ===")
    for idx1, idx2, idx3 in permutations(range(len(pool_variants)), 3):
        for (b1, desc1), (b2, desc2), (b3, desc3) in product(pool_variants[idx1], pool_variants[idx2], pool_variants[idx3]):
            
            b_c3 = b1 + b2 + b3
            desc_c3 = f"[{desc1} + {desc2} + {desc3}]"
            if len(b_c3) == 32 and verify_final_key(b_c3.hex(), desc_c3): return
            for h_name, h_hex in apply_hash_methods(b_c3):
                if verify_final_key(h_hex, f"{desc_c3} -> {h_name}"): return
                
            b_xor3 = xor_bytes(xor_bytes(b1, b2), b3)
            desc_xor3 = f"[[{desc1} XOR {desc2}] XOR {desc3}]"
            if len(b_xor3) == 32 and verify_final_key(b_xor3.hex(), desc_xor3): return
            for h_name, h_hex in apply_hash_methods(b_xor3):
                if verify_final_key(h_hex, f"{desc_xor3} -> {h_name}"): return

    print("\n=== ADVANCED SEARCH COMPLETED ===")
    print("No keys found using concatenations, XOR operations, or modular additions.")

if __name__ == "__main__":
    main()

data.txt example:

Code:

Sacrifice to Lauda!
Sacrifice to Lauda
😼 Sacrifice to Lauda! (topic=5282911)
653384
Goodbye, world!
https://bitcointalk.org/index.php?topic=5282911
000000000fdf0c619cd8e0d512c7e2c0da5a5808e60f12f1e0d01522d2986a51
Lauda
9 lives
Pi Day
2021-03-14
block 653384
1602809821
fabe6d6d11db95a86cae8529510a9bf84dc06f02224de97a798af7896934b90f53115883
😼😼😼😼😼😼😼😼😼
😼 Sacrifice to Lauda!
Sacrifice to Lauda! (topic=5282911)
Sacrifice to Lauda! (https://bitcointalk.org/index.php?topic=5282911)
Sacrifice to Lauda! (Goodbye, world!)
😼 Sacrifice to Lauda! (Goodbye, world!)
😼 Sacrifice to Lauda! (https://bitcointalk.org/index.php?topic=5282911)
Goodbye
Oct 19, 2020
2020-10-19
Kitty
7e972a91c26a2eddba9cf5813e85c2286b8e014d746a9696e6635415b4e95aad
00000000000000000005f564756858e765507df01f547144e05b90f4886f452a
f09f98bc2053616372696669636520746f204c61756461212028746f7069633d3532383239313129
6a28f09f98bc2053616372696669636520746f204c61756461212028746f7069633d3532383239313129
02000000000101c481eef584a17c0fd36a3802f5a7ab972ad06f628ffb57144b865850f9a7fc400200000000feffffff0301000000000000002a6a28f09f98bc2053616372696669636520746f204c61756461212028746f7069633d3532383239313129a0860100000000001600145ab6db66fb0dd08ecb238f07141ffea56189552deeca0600000000001600142a81628ca874ff8ecb9f879a81ae2fa5689850dc02473044022053310e70c23aa279b05cad3527bac28727a4615b9872be4e748cd91a78e5d76c02207d740b8a6904c0d391296249c7773515d947ce8535fc20637c3eb8020eb79f1801210227eb9f073f99f26c8ce69b17aec1bcee7b414ff4bae5b1b3ab0a710b63da62cf48f80900
bc1qjvm9jkrjw9uvsn8905dwa6eau0guyc9laau03a
bc1q92qk9r9gwnlcajuls7dgrt30545fs5xuff30an
0227eb9f073f99f26c8ce69b17aec1bcee7b414ff4bae5b1b3ab0a710b63da62cf
27eb9f073f99f26c8ce69b17aec1bcee7b414ff4bae5b1b3ab0a710b63da62cf
0000000000000000000c3495bbea3d244522a0fa65f777dd7b4099b18effe2aa
010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff6403f8b1092cfabe6d6d9003c9883ba807c6897c90ea84de4a894533a24195e110c74a7ed4c0343793d210000000f09f909f082f4632506f6f6c2f144d696e6564206279206272616e646f6e7365616e00000000000000000000000000000005005420000000000000047327ed26000000001976a914c825a1ecf2a6830c4401620c3a16f1995057c2ab88ac00000000000000002f6a24aa21a9ed2338209e09df008fd236542a41891e0c186b04bc9071689fea6c76eada90f45308000000000000000000000000000000002c6a4c2952534b424c4f434b3a6dab74f9ac1db5fa13da80353122c08557266b98a5df8c129728261d002576810000000000000000266a24b9e11b6d16d7ab970ff8e0862d7eea10da6300919ece05bfc05d57c4bfd0a51adbb06fb401200000000000000000000000000000000000000000000000000000000000000000fde7de3b
fa6dad800522eb1236d453732d8da3ebd26015617c921bfcc97ef51ca76b98c8
0x9bd30411
010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff6403334b0a2cfabe6d6d2d030e5d6216bddae78f49718176906f7926bb4dde62d516cf79747c74bd0a8b10000000f09f909f082f4632506f6f6c2f134d696e6564206279206c61696e66696e6974610000000000000000000000000000000005000c610000000000000379581c28000000001976a914c825a1ecf2a6830c4401620c3a16f1995057c2ab88ac0000000000000000266a24aa21a9ed2b2c519c282fff953498d7576d39bd84ffb6ead349c99e8bc912f87f41ef91110000000000000000266a24b9e11b6d227acb8b5aa8e4dd2439308e5e0735235814e9bf82aac563b80cc129aa1c0dd101200000000000000000000000000000000000000000000000000000000000000000b50f6f39
0x1711d4f2
15784744305477.408
5ab6db66fb0dd08ecb238f07141ffea56189552d
00145ab6db66fb0dd08ecb238f07141ffea56189552d
https://bitcointalk.org/index.php?action=profile;u=101872
u=101872
101872
The Times 03/Jan/2009 Chancellor on brink of second bailout for banks
Thank you everyone in advance, quite the 9 lives that some Kitty had here.
It has been a wild forum life, - or perhaps, nine forum lives involving everything from the dark arts of moderation, to being burnt at the stake several times. (I got better.) Thanks to my forum friends, fans, and cult votaries.
Thank you everyone in advance, quite the 9 lives that some Kitty had here
Cult of Lauda
0x0009f848
48f80900
0xfffffffe
6a20db4b57d9dd5779b04988bd4520de55f44f84d76fd7d594a6ea53f49bb8ce380e
j KWWyIE UOoՔS8
001493365958727178c84ce57d1aeeeb3de3d1c260bf
93365958727178c84ce57d1aeeeb3de3d1c260bf
 ,mmɈ;Ɖ|JE3AJ~47🐟/F2Pool/Mined by brandonseanT 
aa21a9ed2338209e09df008fd236542a41891e0c186b04bc9071689fea6c76eada90f453
52534b424c4f434b3a6dab74f9ac1db5fa13da80353122c08557266b98a5df8c129728261d00257681
6a24b9e11b6d16d7ab970ff8e0862d7eea10da6300919ece05bfc05d57c4bfd0a51adbb06fb4
19db646767c4dfec609f19532b3ce466dcc4f2bdf0ea743528ceccb1789023bd
1.004.464.125
‎2021-03-14 12:51:24