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

[ertil]

What's wrong with my setup?

Your setup does not try to express "pi" as a private key under secp256k1.

I don't know how he did it, but there is surely a very, very original logic in the construction of the private key.

I guess it is just a "pi" value, up to some digits, which gives a hash, starting with nine leading zeroes. It could be hard to generate, if you would need to check around 2^36 combinations for 9 nibbles, but it could be easy to claim, if you could just extract the right offset from the transaction. And then, if you would know, that it is just "next 64 hex digits of pi, starting from 0xbadc0ded", then you could just apply this formula, and claim it: https://giordano.github.io/blog/2017-11-21-hexadecimal-pi/

Of course, I don't know the solution, but this is my guess, and this is how I would do that, if I would want to make a pi-based puzzle.

Edit: Some signet demonstration, how it could look like: https://mempool.space/signet/tx/489405ffa05f3bf0bc9554275e1e3bcae46b4417694ee6912e1ba9326f81197f

I can see somebody moved the coins with the private key, equal to 3. But nobody calculated the private key for "3.1", "3.14", and so on. I guess here, the puzzle is similar to that, but it is probably expressed in hexadecimal, instead of decimal, and you have to know the offset, to read only hex digits, between a given range, without having to compute any preceding ones, by using things like Bailey–Borwein–Plouffe formula.

[stwenhao]

I guess it is just a "pi" value, up to some digits

It could be the "exact" pi value instead. Why? Because even if it is a transcendental number, then secp256k1 is a finite field. Which means, that some values can be expressed exactly.

For example: it is possible to create a private key, equal to exactly the square root of 1/2. Why? Because by multiplying it by itself, it can give back exactly one half. And maybe, there is some formula, where the "pi", raised to some power, or combined with some expression, would give some nice number, like "e^(i*pi)=(-1)". This one is particularly interesting, because of burning one satoshi.

Code:

n=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
sqrt(1/2)=0x31f25c116881d18d2426af7e0b26f40922458624107cabc306e00347ff09e30
sqrt(1/2)*sqrt(1/2)=0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1

And then, maybe there is "-1", which can be easily expressed as 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140, combined with some "e" representation, whatever it would be. For "i", this is just "sqrt(-1)". And then, the whole puzzle would be all about finding some "pi" value, which would give exactly 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140, when combined with other values. Which is interesting, because this value can be often reached, when different numbers are raised to some powers in a finite field.

[athanred]

For "i", this is just "sqrt(-1)".

There are two matching values, and I don't know, which one should be used.

Code:

n=fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
3^1fffffffffffffffffffffffffffffffd755db9cd5e9140777fa4bd19a06c828 mod n = 8f52b651807a8b13549be5bd4c5db0dbe4779cc31afbd9d61915afdbdcba81c9
8f52b651807a8b13549be5bd4c5db0dbe4779cc31afbd9d61915afdbdcba81c9^2 mod n = fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140
8f52b651807a8b13549be5bd4c5db0dbe4779cc31afbd9d61915afdbdcba81c9^3 mod n = 70ad49ae7f8574ecab641a42b3a24f22d6374023944cc665a6bcaeb0f37bbf78
70ad49ae7f8574ecab641a42b3a24f22d6374023944cc665a6bcaeb0f37bbf78^2 mod n = fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140

So, where is "i-value"? Is it 70ad49ae7f8574ecab641a42b3a24f22d6374023944cc665a6bcaeb0f37bbf78 or 8f52b651807a8b13549be5bd4c5db0dbe4779cc31afbd9d61915afdbdcba81c9? One of them is "i-value", another one is "negative i-value".

[icopress]

The balance of the address associated with the puzzle continues to grow.

nullius welcome back, everyone—have a great upcoming weekend. 

https://mempool.space/ru/address/bc1qt2mdkehmphggajer3ur3g8l754scj4fdrmw3rn

[nullius]

😼🦇  6 years, 3 days after the catbat flew away, what have we here?

data.txt example:

Off the top of my head, I think that your data.txt contains every bit of information needed to reconstruct the key.  Well, I’m not sure without walking back through it.  I should double-check if I can reconstruct the key from your file—without directly examining the blockchain, and without reference to the source code that I wrote over five and a half years ago.

But your way of processing it is a waste of CPU cycles.

I will give no further hints.  I may give further disinformation to befuddle searchers with false leads.  Lolz.

At the risk of breaking my word about “no further hints”:

• I don't know how he did it, but there is surely a very, very original logic in the construction of the private key.
  

  To solve it, you need to think like nullius.

  
  I’ve spent time fussing with various Bitcoin standards.  I wonder, how could I abuse Bitcoin standards to torture a private key out of some arbitrary strings?
  
  On the other hand, I could just be saying that to encourage people to study the Bitcoin standards.
  
  
• Pi Day could be a mere coincidence.  Or I could just be saying that, to throw you off the trail.

It is a trick wrapped in a riddle wrapped in a meow.

The balance of the address associated with the puzzle continues to grow.

What magical seed have I planted in this laudatory permathread, that the money grows as if by witchcraft?

nullius welcome back, everyone—have a great upcoming weekend. 

Thanks.  I’ve really been away, not lurking.  It’ll take me a long time to catch up, if I ever do. 😿

I wonder if Lauda knows, or can know that her goodbye thread is still going.  But such curiosity is like an unobservable version of Schrödinger’s cat.

[icopress]

[...] I wonder if Lauda knows, or can know that her goodbye thread is still going.  But such curiosity is like an unobservable version of Schrödinger’s cat.

Don’t worry about it; as long as I’m online, this thread will remain active (not to mention the other followers of the feline cult), and the puzzle’s BTC address will be topped up periodically. I hope you’ll be staying with us for a good while; despite your rather particular reputation, we’ve all been missing some sharp, provocative opinions.

[OgNasty]

While I do think the puzzle is just trolling and don’t think the BTC will ever be claimed, I figured I might as well let my AI take a shot at it since I have the extra usage available. So far it has tried nearly 100,000 combinations using clues from the thread and I just started it a few minutes ago. Not expecting anything, but figured I’d mention it.

After the initial pass, this was the comment it made.
“The odds are still long, but it's the best lead anyone has had.”

Edit: 268 million different attempts made to find the key using the clues on this thread. It determined that no bitcoin standard trick solves this problem with the available information. I told it that no Bitcoin trick will solve the problem and it must think like nullius, so it is combing nullius’ posts and will use that information to try and find the solution. I think that will be as far as I’m willing to go with it.

[JayJuanGee]

[...] I wonder if Lauda knows, or can know that her goodbye thread is still going.  But such curiosity is like an unobservable version of Schrödinger’s cat.

Don’t worry about it; as long as I’m online, this thread will remain active (not to mention the other followers of the feline cult), and the puzzle’s BTC address will be topped up periodically. I hope you’ll be staying with us for a good while; despite your rather particular reputation, we’ve all been missing some sharp, provocative opinions.

Hopefully, nullius got some of his shit together since the last time that he was somewhat active in these here parts (2022-ish), especially referring to his shit together financially and psychologically.

At the same time, I would like to thank nullius for inspiring me in early stage aspects of my time-based sustainable withdrawal models and ideas (can be seen in my sustainable withdrawal thread).

[GazetaBitcoin]

I wonder if Lauda knows, or can know that her goodbye thread is still going.  But such curiosity is like an unobservable version of Schrödinger’s cat.

as long as I’m online, this thread will remain active (not to mention the other followers of the feline cult), and the puzzle’s BTC address will be topped up periodically. I hope you’ll be staying with us for a good while; despite your rather particular reputation, we’ve all been missing some sharp, provocative opinions.

While thanking to icopress for his generosity, what he said is true. He kept this thread active during time.

And, of course, welcome back nullius! Your experience in cryptography was, is and will always be needed And I am sure that, if Lauda saw / sees this topic, she giggles and is happy...

[athanred]

Target Cat: 19GesPtWCfX4R1SVmgJqzGLjh25FEbn5go
Found Cats:

Code:

+---------------+------------------------------------+
| Cats in order | Address                            |
+---------------+------------------------------------+
|            61 | 1GexAgZ9A98iDr9iMhU73XcJHFFSuf873w |
|           268 | 1EsNDdBmcX1AEUkwNBexqNEANevFFt6ZvK |
+---------------+------------------------------------+

Repeated Cats:

Code:

+----------------+------------------------------------+
| Number of Cats | Address                            |
+----------------+------------------------------------+
|            214 | /* invalid checksum */             | //starts with 0x000021c9
|            283 | 17xjT7Hns8mwucoVzANSLyzWPGmmhK5hGd |
+----------------+------------------------------------+

As you can see, I guess I found some clues. If I did it correctly, then it should work. However, it may be harder than I thought, to convert things from hexadecimal or decimal into base9 (nonal? system), and preserve checksum.

I guess I should write some code, because hitting 18-bit target with 214 cats is quite unusual, it should happen after much, much more tries (and it is the case, if I switch to a different cat, for example from the fifth to the first one). Or, maybe it is just a mathematical coincidence.

Anyway, bruteforcing all cats means checking around 2^45 combinations, if there are 14 of them. And still, it wouldn't work, if they are simply repeated, or if yet another pattern is in use.