Saatoshi_Rising Said

Hello everyone,

As you know the puzzle creator said that in his first & last post;

"I am the creator.
You are quite right, 161-256 are silly.  I honestly just did not think of this.  What is especially embarrassing, is this did not occur to me once, in two years.  By way of excuse, I was not really thinking much about the puzzle at all.
I will make up for two years of stupidity.  I will spend from 161-256 to the unsolved parts, as you suggest.  In addition, I intend to add further funds.  My aim is to boost the density by a factor of 10, from 0.001*length(key) to 0.01*length(key).  Probably in the next few weeks.  At any rate, when I next have an extended period of quiet and calm, to construct the new transaction carefully.
A few words about the puzzle.  There is no pattern.  It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty).  It is simply a crude measuring instrument, of the cracking strength of the community.
Finally, I wish to express appreciation of the efforts of all developers of new cracking tools and technology.  The "large bitcoin collider" is especially innovative and interesting!"

It means, he created the all puzzle with a deterministic wallet and masked related key to measure the community's cracking strength. So, I prepared the below script as on his own way;

#!/usr/bin/env python3

import hashlib

import hmac

import base58

import struct

import os

import sys

import time

from hashlib import pbkdf2_hmac

from mnemonic import Mnemonic

import multiprocessing

from coincurve import PublicKey

N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

def private_key_to_public_key_compressed(priv_key_bytes):

try:

return PublicKey.from_secret(priv_key_bytes).format(compressed=True)

except Exception:

return None

def public_key_to_address(pub_key_bytes):

if pub_key_bytes is None: return ""

sha = hashlib.sha256(pub_key_bytes).digest()

rip = hashlib.new('ripemd160', sha).digest()

payload = b'\x00' + rip

checksum = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]

return base58.b58encode(payload + checksum).decode()

def private_key_to_wif_compressed(priv_key_bytes):

extended_key = b'\x80' + priv_key_bytes

extended_key += b'\x01'

first_sha = hashlib.sha256(extended_key).digest()

second_sha = hashlib.sha256(first_sha).digest()

checksum = second_sha[:4]

return base58.b58encode(extended_key + checksum).decode()

def mnemonic_to_seed(mnemonic_str, passphrase=""):

return pbkdf2_hmac('sha512', mnemonic_str.encode('utf-8'),

f"mnemonic{passphrase}".encode('utf-8'), 2048, 64)

def bip32_master_key_from_seed(seed_bytes):

I = hmac.new(b"Bitcoin seed", seed_bytes, hashlib.sha512).digest()

return I[:32], I[32:]

def derive_bip42_step(current_priv, current_chain, index):

if index >= 0x80000000:

data = b'\x00' + current_priv + struct.pack('>I', index)

else:

pub_comp = private_key_to_public_key_compressed(current_priv)

if pub_comp is None: return current_priv, current_chain

data = pub_comp + struct.pack('>I', index)

I = hmac.new(current_chain, data, hashlib.sha512).digest()

IL, IR = I[:32], I[32:]

il_int = int.from_bytes(IL, 'big')

parent_int = int.from_bytes(current_priv, 'big')

if il_int >= N:

return current_priv, current_chain

child_priv_int = (il_int + parent_int) % N

if child_priv_int == 0:

return current_priv, current_chain

return child_priv_int.to_bytes(32, 'big'), IR

def load_target_addresses(filename="160.txt"):

if not os.path.exists(filename):

print(f"❌ Hata: {filename} dosyası bulunamadı!")

sys.exit(1)

addresses_with_index = {}

with open(filename, "r", encoding="utf-8") as f:

for idx, line in enumerate(f, start=1):

addr = line.strip()

if addr:

addresses_with_index[addr] = idx

return addresses_with_index

def generate_12_word_mnemonic(mno_obj):

return mno_obj.generate(strength=128)

def worker_process(worker_id, target_addresses, shared_counter, shared_preview, lock):

mno = Mnemonic("english")

bip44_fixed_indices = [0x8000002C, 0x80000000, 0x80000000, 0]

while True:

with lock:

shared_counter.value += 1

local_count = shared_counter.value

seed_phrase = generate_12_word_mnemonic(mno)

seed_bytes = mnemonic_to_seed(seed_phrase)

master_priv, master_chain = bip32_master_key_from_seed(seed_bytes)

current_priv = master_priv

current_chain = master_chain

for idx in bip44_fixed_indices:

current_priv, current_chain = derive_bip42_step(current_priv, current_chain, idx)

detected_details = []

has_big_target = False

sample_hex_71 = ""

for index in range(160):

raw_priv, = derivebip42_step(current_priv, current_chain, index)

raw_priv_int = int.from_bytes(raw_priv, 'big')

target_bit_length = index + 1

shift_amount = 256 - target_bit_length

# BIT SHIFTING

shifted_int = raw_priv_int >> shift_amount

# Yasal Taban Sınır Çivisi

legal_base = 1 << index

manipulated_int = legal_base | shifted_int

manipulated_int = manipulated_int % N

if manipulated_int == 0:

manipulated_int = 1

manipulated_priv = manipulated_int.to_bytes(32, 'big')

# 🎯 CANLI ÖNİZLEME İÇİN PUZZLE #71 (Satır 71 / Index 70) SEÇİLDİ:

if index == 70:

sample_hex_71 = manipulated_priv.hex()

pub_comp = private_key_to_public_key_compressed(manipulated_priv)

if pub_comp is None: continue

addr_compressed = public_key_to_address(pub_comp)

if addr_compressed in target_addresses:

line_number = target_addresses[addr_compressed]

priv_hex = manipulated_priv.hex()

priv_wif = private_key_to_wif_compressed(manipulated_priv)

detected_details.append((addr_compressed, line_number, priv_hex, priv_wif))

if line_number > 70:

has_big_target = True

match_count = len(detected_details)

if local_count % 500 == 0:

shared_preview['seed'] = seed_phrase

shared_preview['p71_hex'] = sample_hex_71

if match_count >= 5:

with lock:

print(f"\n────────────────────────────────────────────────────────")

print(f"🔥 [ŞÜPHELİ ALGORİTMA (BİT KAYDIRMA) | Çekirdek-{worker_id}]")

print(f"🔑 Seed (12 Kelime): {seed_phrase}")

print(f"📊 Toplam Eşleşme Sayısı: {match_count}")

print(f"🎯 Yakalanan Adreslerin Dosyadaki Detayları:")

for addr, line, priv_h, priv_w in detected_details:

status = "🔓 ÇÖZÜLMÜŞ (İlk Adresler)" if line <= 65 else "🚨 ÇÖZÜLMEMİŞ BÜYÜK HEDEF!"

print(f" • [Satır {line}] {addr} -> {status}")

print(f"────────────────────────────────────────────────────────\n", flush=True)

if has_big_target:

with lock:

with open("winnerseed.txt", "a", encoding="utf-8") as wf:

wf.write(f"=== 🚨 BÜYÜK HEDEF YAKALANDI (Zaman: {time.strftime('%Y-%m-%d %H:%M:%S')}) ===\n")

wf.write(f"Winner Seed Phrase: {seed_phrase}\n")

for addr, line, priv_h, priv_w in detected_details:

wf.write(f" - Satır {line}: {addr}\n")

wf.write(f" 🔑 HEX PRIVATE KEY : {priv_h}\n")

wf.write(f" 🔑 COMPRESSED WIF KEY : {priv_w}\n")

wf.write("=" * 60 + "\n\n")

def main():

target_addresses = load_target_addresses("160.txt")

total_targets = len(target_addresses)

print(f"🎯 {total_targets} adet hedef bulmaca adresi hafızaya yüklendi.")

num_cores = 2

print(f"🚀 C-Tabanlı Dedektif Motoru {num_cores} Çekirdek ile Başlatıldı...\n")

shared_counter = multiprocessing.Value('i', 0)

manager = multiprocessing.Manager()

shared_preview = manager.dict()

shared_preview['seed'] = "Başlatılıyor..."

shared_preview['p71_hex'] = "0000000000000000"

lock = multiprocessing.Lock()

start_time = time.time()

processes = []

for i in range(num_cores):

p = multiprocessing.Process(target=worker_process, args=(i, target_addresses, shared_counter, shared_preview, lock))

processes.append(p)

p.start()

try:

while True:

time.sleep(0.5)

elapsed = time.time() - start_time

current_count = shared_counter.value

speed = current_count / elapsed if elapsed > 0 else 0

sys.stdout.write("\033[H\033[J")

sys.stdout.write(f"🎯 Hedef Adres Sayısı: {total_targets}\n")

sys.stdout.write(f"📈 [SAYAÇ] İşlenen Toplam Set: {current_count:,} | Süre: {elapsed:.1f} sn | Hız: {speed:.2f} set/sn\n")

sys.stdout.write(f"───────────────────────────────────────────────────────────────────────────────\n")

sys.stdout.write(f"🔑 [CANLI İZLENEN SEED (12 KELİME)]:\n 👉 {shared_preview.get('seed')}\n\n")

sys.stdout.write(f"🧮 [MATEMATİKSEL ARALIK DOĞRULAMA (Puzzle #71 Örneği)]:\n")

sys.stdout.write(f" • Üretilen Hex : {shared_preview.get('p71_hex')}\n")

sys.stdout.write(f" 💡 (Not: Yukarıdaki Hex değerinin '00000000000000000000000000000040...' veya '...4a/5b/6c/7f...' yani\n")

sys.stdout.write(f" tam 71. bit yasal aralığında başladığını buradan canlı olarak doğrulayabilirsiniz.)\n")

sys.stdout.write(f"───────────────────────────────────────────────────────────────────────────────")

sys.stdout.flush()

except KeyboardInterrupt:

print("\n👋 Tarama durduruluyor...")

for p in processes:

p.terminate()

p.join()

if name == "__main__":

multiprocessing.freeze_support()

main()


The bip39 words will come with script's running, but you only need 160.txt which includes all puzzles compressed addresses. I reached first 24 address until now, but I believe that there is someone who is more luckier than me and reach all puzzles solutions.

Take care community!