import secp256k1 as ice
from mnemonic import Mnemonic
from bitcoin import *
from pathlib import Path
from bloomfilter import BloomFilter, ScalableBloomFilter, SizeGrowthRate
import time
import os


mys = Path(__file__).resolve()
fil = mys.parents[1] 'found/found.txt'

myself = Path(__file__).resolve()
res = myself.parents[1] 'datafiles/wordlist/english.txt'

myselff = Path(__file__).resolve()
ress = myselff.parents[1] 'datafiles/BF/Addresses.bf'


with open(res) as f:
    wordlist = f.read().split('\n')

with open(ress, "rb") as fp:
    bloom_filter = BloomFilter.load(fp)
strength = 256
found = 0
phrase = 0
count = 0
while True:
   
    rbytes = os.urandom(strength/ 8)
    h = hashlib.sha256(rbytes).hexdigest()

    b = ( bin(int.from_bytes(rbytes, byteorder="big"))[2:].zfill(len(rbytes) * 8) \
         + bin(int(h, 16))[2:].zfill(256)[: len(rbytes) * 8/ 32] )

    result = []
    for i in range(len(b)/ 11):
        idx = int(b[i * 11 : (i + 1) * 11], 2)
        result.append(wordlist[idx])

    mnemonic = " ".join(result)
    phrase+=1
    backup_phrase = mnemonic
    mnemo = Mnemonic("english")
    seed = mnemo.to_seed(backup_phrase)
    master_key = bip32_master_key(seed)
    path = "m/44h/0h/0h/0/"   
    last_index = 8
    while last_index <= 160:
        index_path = path + str(last_index)
        indices = [int(i[:-1]) | 0x80000000 if i[-1] == "h" else int(i) for i in index_path.split("/") if i != "m"]
        derived_key = master_key
        for index in indices:
            derived_key = bip32_ckd(derived_key, index)
        private_key = bip32_extract_key(derived_key)
        compressed_private_key = encode_privkey(private_key, 'hex_compressed')
        hexa = compressed_private_key[:64]
        mask = 1 << last_index
        first_key = mask + int(hexa, 16) % mask
        first_key_hex = format(first_key, 'x').zfill(64)
        mask_hex = format(mask, 'x').zfill(64)
        hex = first_key_hex
        pvk = bytes.fromhex(str(hex))
        pvk2 = bytes.fromhex(str(hexa))
        addr1 = ice.privatekey_to_address(0, True, (int.from_bytes(pvk, "big")))
        addr2 = ice.privatekey_to_address(0, True, (int.from_bytes(pvk2, "big")))
        last_index += 1
        count += 1
        if addr2 in bloom_filter:
            print("BTC p2pkh comp:         \n" +addr2)
            print(hexa)
            print(backup_phrase + "\n"+ "\n")
            g=open(fil,"a")
            g.write("BTC p2pkh comp:         \n" +addr2)
            g.write("\n"+hexa)
            g.write("\n"+str(backup_phrase) + "\n"+ "\n")
            g.close()
            found += 1
        if addr1 in bloom_filter:
            print("BTC p2pkh comp:         \n" +addr1)
            print(hex)
            print(backup_phrase + "\n"+ "\n")
            g=open(fil,"a")
            g.write("BTC p2pkh comp:         \n" +addr1)
            g.write("\n"+hex)
            g.write("\n"+str(backup_phrase) + "\n"+ "\n")
            g.close()
            found += 1
        else: print('\n\n ================================ Deterministic wallet masked with leading Zeros ==================================\n\n'"Bip44 : "+mnemonic+"\nBipPH : "+index_path+"\nPhras : "+str(phrase)+"\ncount : "+str(count * 2)+"\nFound : "+str(found)+"\nPrivM : "+hexa+"\nMaskM : "+mask_hex+"\nMaskp : "+hex+"\nAddrp : "+addr1+"\nAddrM : "+addr2, end='\r')
       

#!/usr/bin/env python3
"""
Electrum Çoklu Kelime Uyumlu & Bit Shifting Tabanlı Bitcoin Puzzle Dedektörü
------------------------------------------------------------------------
Desteklenen Kelime Sayıları: 12, 13, 15, 18, 21, 24
Koşul: 160.txt dosyasında Satır 25'ten büyük (Satır > 25) bir eşleşme bulursa kaydeder.
Canlı İzleme: Anlık eşleşen adres-hex matrisini ve toplam eşleşme sayısını ekranda gösterir.
Kurulum için: pip install coincurve base58
"""

import hashlib
import hmac
import base58
import struct
import os
import sys
import time
import secrets
import multiprocessing
from hashlib import pbkdf2_hmac
from coincurve import PublicKey

N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

# --- KRİPTOGRAFİ VE ADRES TÜRETME FONKSİYONLARI ---

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 electrum_mnemonic_to_seed(mnemonic, passphrase=""):
    return pbkdf2_hmac("sha512", mnemonic.encode("utf-8"), f"electrum{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

# --- İŞÇİ ÇEKİRDEK (WORKER PROCESS) PROTOKOLÜ ---

def worker_process(worker_id, target_addresses, WORDS, word_choice, shared_counter, shared_preview, lock):
    seed_version_bytes = b"Seed version"
    bip44_fixed_indices = [0x8000002C, 0x80000000, 0x80000000, 0]
   
    while True:
        # Seçilen kelime sınırına göre dinamik kombinasyon üretimi
        word_list_sample = [secrets.choice(WORDS) for _ in range(word_choice)]
        seed_phrase = " ".join(word_list_sample)
       
        h = hmac.new(seed_version_bytes, seed_phrase.encode('utf-8'), hashlib.sha512).digest()
        # Electrum Standart/Legacy Cüzdan ön ek doğrulama kuralı
        if h[0] != 1:
            continue
           
        with lock:
            shared_counter.value += 1
            global_valid_count = shared_counter.value

        seed_bytes = electrum_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)
           
        sample_hex_71 = ""
        current_seed_matches = []
       
        for index in range(160):
            raw_priv, _ = derive_bip42_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
           
            shifted_int = raw_priv_int >> shift_amount
            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')
           
            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()
               
                # Arayüz matris yapısı için kısaltma
                short_hex = f"{priv_hex[:8]}...{priv_hex[-8:]}"
                short_addr = f"{addr_compressed[:6]}...{addr_compressed[-6:]}"
                current_seed_matches.append(f"Hex: {short_hex} = {short_addr} (Satır {line_number})")
               
                if line_number > 25:
                    priv_wif = private_key_to_wif_compressed(manipulated_priv)
                   
                    with lock:
                        print(f"\n🎯 🎯 HEDEF BULUNDU! SATIR {line_number} ÜZERİNDE EŞLEŞME! 🎯 🎯")
                        print(f"🔑 Seed ({word_choice} Kelime): {seed_phrase}")
                        print(f"🏠 Adres: {addr_compressed}")
                       
                        with open("winnerseed.txt", "a", encoding="utf-8") as wf:
                            wf.write(f"=== 💎 PUZZLE MATCH ({word_choice} Words) | Zaman: {time.strftime('%Y-%m-%d %H:%M:%S')} ===\n")
                            wf.write(f"Geçerli Seed Phrase : {seed_phrase}\n")
                            wf.write(f"Eşleşen Adres       : {addr_compressed}\n")
                            wf.write(f"160.txt Satır No    : {line_number}\n")
                            wf.write(f"🔑 HEX PRIVATE KEY    : {priv_hex}\n")
                            wf.write(f"🔑 COMPRESSED WIF KEY : {priv_wif}\n")
                            wf.write("=" * 75 + "\n\n")
                        print("💾 Detaylar 'winnerseed.txt' dosyasına kaydedildi.\n")
               
        if global_valid_count % 10 == 0 or len(current_seed_matches) > 0:
            shared_preview['seed'] = seed_phrase
            shared_preview['p71_hex'] = sample_hex_71
            shared_preview['matches'] = current_seed_matches
            shared_preview['total_matches'] = len(current_seed_matches)

# --- ANA MOTOR KONTROL PANELİ ---

def main():
    print("🚀 Esnek Kelime Seçenekli Electrum Bit Shifting Puzzle Dedektörü")
    print("───────────────────────────────────────────────────────────────────────────────")
   
    valid_choices = [12, 13, 15, 18, 21, 24]
    print(f"💡 Kullanılabilir Electrum kelime varyasyonları: {valid_choices}")
   
    try:
        word_choice = int(input("👉 Kaç kelimelik seed aramak istiyorsunuz?: ").strip())
        if word_choice not in valid_choices:
            print("❌ Geçersiz seçim! Program kapatılıyor.")
            return
    except ValueError:
        print("❌ Lütfen sadece sayısal bir değer giriniz!")
        return

    target_addresses = load_target_addresses("160.txt")
    total_targets = len(target_addresses)
    print(f"🎯 {total_targets} adet hedef bulmaca adresi hafızaya yüklendi.")
   
    words_file = "kelimeler.txt"
    if not os.path.exists(words_file):
        print(f"❌ Hata: '{words_file}' bulunamadı!")
        return
    with open(words_file, "r", encoding="utf-8") as f:
        WORDS = [line.strip() for line in f if line.strip()]
    print(f"✅ {len(WORDS)} kaynak kelime havuzu yüklendi.")
   
    num_cores = 3
    print(f"🚀 Hibrit Dedektif Motoru {num_cores} Çekirdek ({word_choice} Kelime Modu) ile Başlatılıyor...\n")
   
    shared_counter = multiprocessing.Value('i', 0)
    manager = multiprocessing.Manager()
    shared_preview = manager.dict()
    shared_preview['seed'] = "Filtreleme Başlatılıyor..."
    shared_preview['p71_hex'] = "0000000000000000"
    shared_preview['matches'] = []
    shared_preview['total_matches'] = 0
   
    lock = multiprocessing.Lock()
    start_time = time.time()
    processes = []
   
    for i in range(num_cores):
        p = multiprocessing.Process(
            target=worker_process,
            args=(i, target_addresses, WORDS, word_choice, shared_counter, shared_preview, lock)
        )
        processes.append(p)
        p.start()
       
    try:
        while True:
            time.sleep(0.4)
            elapsed = time.time() - start_time
            current_count = shared_counter.value
            speed = current_count elapsed if elapsed > 0 else 0
           
            # Konsol yenileme
            sys.stdout.write("\033[H\033[J")
            sys.stdout.write(f"🎯 Hedef Bulmaca Adres Havuzu : {total_targets} | Aktif Mod: {word_choice} Kelime\n")
            sys.stdout.write(f"📈 [FİLTRE] İşlenen Geçerli Electrum Seed Seti: {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 GEÇERLİ SEED ({word_choice} KELİME)]:\n   👉 {shared_preview.get('seed')}\n\n")
           
            sys.stdout.write(f"🔍 [ANLIK SEED MATRİSİNDEKİ EŞLEŞMELER]:\n")
            matches_list = shared_preview.get('matches', [])
            if matches_list:
                for match_line in matches_list[:6]:
                    sys.stdout.write(f"   • {match_line}\n")
                if len(matches_list) > 6:
                    sys.stdout.write(f"   • ... ve {len(matches_list) - 6} adres eşleşmesi daha var.\n")
            else:
                sys.stdout.write(f"   (Bu evrende henüz bir 160.txt adres çakışması saptanmadı.)\n")
               
            sys.stdout.write(f"\n📊 Toplam Eşleşme = {shared_preview.get('total_matches', 0)}\n")
            sys.stdout.write(f"───────────────────────────────────────────────────────────────────────────────\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"───────────────────────────────────────────────────────────────────────────────")
            sys.stdout.flush()
           
    except KeyboardInterrupt:
        print("\n👋 Tarama durduruluyor, çekirdekler kapatılıyor...")
        for p in processes:
            p.terminate()
            p.join()

if __name__ == "__main__":
    multiprocessing.freeze_support()
    main()