Update app.py

app.py

@@ -1,16 +1,29 @@
-# debug_derive.py
-import hashlib, hmac
+from itertools import permutations, combinations
+import hashlib, hmac, os, time, math, gc
+from multiprocessing import Pool
 from eth_account import Account
-from mnemonic import Mnemonic
-from eth_utils import keccak, to_checksum_address
 import coincurve
+from eth_utils import keccak, to_checksum_address
 
-Account.enable_unaudited_hdwallet_features()
+# ============================================================
+words = [
+    "lesson", "cushion", "crane", "affair", "federal",
+    "decline", "limb", "spend", "reunion", "chief", "cart", "zebra",
+]
 
-phrase = "lesson cushion crane affair federal decline limb spend reunion chief cart zebra"
-TARGET = "0x3f0482fc3e9132c3d3acb5f588e980d7b3a5af07"
+PHRASE_MODE = "replace"
+USE_BIP39   = True
+BIP39_PASSPHRASE = ""
+HD_DERIVATION = True
+ADDRESS_INDEX = 0
+CHECK_BIP39_CHECKSUM = True
+ADDRESSES_FILE = "12730802_addresses.csv"
+MATCHED_FILE   = f"matched_keys_{PHRASE_MODE}.txt"
+BATCH_SIZE  = 500
+NUM_WORKERS = 96
+# ============================================================
 
-# --- 1. Aapka manual BIP32 code (jo aapke script mein hai) ---
+# ---------- secp256k1 ----------
 _SECP256K1_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
 _HARDENED    = 0x80000000
 
@@ -34,21 +47,195 @@ def seed_to_privkey_hd(seed, address_index=0):
         key, chain = _bip32_derive_child_priv(key, chain, idx)
     return key
 
-# --- 2. Manual derivation se address ---
-seed = Mnemonic("english").to_seed(phrase, passphrase="")
-priv_manual = seed_to_privkey_hd(seed, 0)
-pub_manual = coincurve.PrivateKey(priv_manual).public_key.format(compressed=False)[1:]
-addr_manual = to_checksum_address(keccak(pub_manual)[-20:])
-
-# --- 3. eth_account se address ---
-acct = Account.from_mnemonic(phrase, account_path="m/44'/60'/0'/0/0")
-addr_standard = acct.address
-
-# --- 4. Result ---
-print(f"Manual BIP32:  {addr_manual}")
-print(f"eth_account:   {addr_standard}")
-print(f"Target:        {TARGET}")
-print()
-print(f"Manual == Target:    {addr_manual.lower() == TARGET.lower()}")
-print(f"eth_account == Target: {addr_standard.lower() == TARGET.lower()}")
-print(f"Manual == eth_account: {addr_manual.lower() == addr_standard.lower()}")
+# ---------- BIP39 ----------
+try:
+    import bip39 as _bip39_rust
+    _USE_RUST_BIP39 = True
+except ImportError:
+    _bip39_rust = None
+    _USE_RUST_BIP39 = False
+
+_MNEMONIC = None
+
+def _get_mnemonic():
+    global _MNEMONIC
+    if _MNEMONIC is None:
+        from mnemonic import Mnemonic
+        _MNEMONIC = Mnemonic("english")
+    return _MNEMONIC
+
+def is_valid_bip39_fast(phrase):
+    if _USE_RUST_BIP39:
+        try:
+            _bip39_rust.bip39_mnemonic_to_entropy(phrase)
+            return True
+        except Exception:
+            return False
+    return _get_mnemonic().check(phrase)
+
+def phrase_to_seed(phrase):
+    if _USE_RUST_BIP39:
+        return _bip39_rust.bip39_mnemonic_to_seed(phrase, BIP39_PASSPHRASE)
+    return _get_mnemonic().to_seed(phrase, passphrase=BIP39_PASSPHRASE)
+
+# ---------- Address file ----------
+def load_addresses(path):
+    s = set()
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            a = line.strip().strip('"').strip("'").lstrip("\ufeff").lower()
+            if a.startswith("0x"):
+                a = a[2:]
+            if a and len(a) == 40:
+                s.add(a)
+    return frozenset(s)
+
+def normalize(addr):
+    a = addr.strip().lower()
+    if a.startswith("0x"):
+        a = a[2:]
+    return a
+
+# ---------- Generator ----------
+def generate_phrases():
+    n = len(words)
+    if PHRASE_MODE == "order":
+        for perm in permutations(words):
+            yield " ".join(perm)
+    elif PHRASE_MODE == "replace":
+        for i in range(n):
+            for w in words:
+                new = words.copy()
+                new[i] = w
+                yield " ".join(new)
+    elif PHRASE_MODE == "subset":
+        for r in range(1, n + 1):
+            for combo in combinations(words, r):
+                yield " ".join(combo)
+
+def count_total():
+    n = len(words)
+    if PHRASE_MODE == "order":   return math.factorial(n)
+    if PHRASE_MODE == "replace": return n * n
+    if PHRASE_MODE == "subset":  return 2**n - 1
+
+# ---------- Worker ----------
+_KNOWN = None
+
+def init_worker(known):
+    global _KNOWN
+    _KNOWN = known
+    _get_mnemonic()
+    # ✅ DEBUG: worker init confirm
+    print(f"🔧 Worker init: known size = {len(known):,}")
+    target = "3f0482fc3e9132c3d3acb5f588e980d7b3a5af07"
+    print(f"   target in known: {target in known}")
+
+def process_batch(batch):
+    hits = []
+    known = _KNOWN
+    m = _get_mnemonic()
+    for phrase in batch:
+        # ✅ DEBUG: har phrase print (sirf pehle 5, taake output flood na ho)
+        if process_batch.counter < 5:
+            print(f"🔍 Process phrase: {phrase}")
+            process_batch.counter += 1
+
+        if CHECK_BIP39_CHECKSUM and not is_valid_bip39_fast(phrase):
+            if process_batch.counter <= 5:
+                print(f"   ❌ Checksum fail: {phrase}")
+            continue
+        try:
+            seed = phrase_to_seed(phrase)
+            if HD_DERIVATION:
+                priv = seed_to_privkey_hd(seed, ADDRESS_INDEX)
+            else:
+                priv = seed[:32]
+            pub = coincurve.PrivateKey(priv).public_key.format(compressed=False)[1:]
+            addr = to_checksum_address(keccak(pub)[-20:])
+        except Exception as e:
+            if process_batch.counter <= 5:
+                print(f"   ❌ Error: {e}")
+            continue
+
+        normalized = normalize(addr)
+        if process_batch.counter <= 5:
+            print(f"   addr: {addr}")
+            print(f"   normalized: {normalized}")
+            print(f"   in known: {normalized in known}")
+            if phrase == "lesson cushion crane affair federal decline limb spend reunion chief cart zebra":
+                target = "3f0482fc3e9132c3d3acb5f588e980d7b3a5af07"
+                print(f"   target: {target}")
+                print(f"   equal: {normalized == target}")
+
+        if normalized in known:
+            hits.append((phrase, priv.hex(), addr))
+    return hits
+
+# Counter attribute (multiprocessing mein kaam karega? nahi, lekin debug ke liye)
+process_batch.counter = 0
+
+def batch_generator():
+    batch = []
+    for phrase in generate_phrases():
+        batch.append(phrase)
+        if len(batch) >= BATCH_SIZE:
+            yield batch
+            batch = []
+    if batch:
+        yield batch
+
+# ---------- Main ----------
+def main():
+    if not os.path.exists(ADDRESSES_FILE):
+        raise SystemExit(f"File nahi mili: {ADDRESSES_FILE}")
+
+    total = count_total()
+    print(f"\nMode: {PHRASE_MODE} | Total: {total:,} | Workers: {NUM_WORKERS}")
+    print(f"HD: {HD_DERIVATION} (index {ADDRESS_INDEX})\n")
+
+    known = load_addresses(ADDRESSES_FILE)
+    print(f"Loaded {len(known):,} lowercase addresses\n")
+
+    # ✅ DEBUG: pehla phrase check
+    first_phrase = next(generate_phrases())
+    print(f"First phrase generated: {first_phrase}")
+    print(f"Target phrase: {repr('lesson cushion crane affair federal decline limb spend reunion chief cart zebra')}")
+    print(f"Match: {first_phrase == 'lesson cushion crane affair federal decline limb spend reunion chief cart zebra'}\n")
+
+    matches = []
+    done = 0
+    start = time.time()
+    last_log = start
+
+    if os.path.exists(MATCHED_FILE):
+        os.remove(MATCHED_FILE)
+
+    gc.collect()
+    gc.freeze()
+
+    with Pool(processes=NUM_WORKERS,
+              initializer=init_worker,
+              initargs=(known,),
+              maxtasksperchild=1000) as pool:
+        for hits in pool.imap_unordered(process_batch, batch_generator(), chunksize=1):
+            done += BATCH_SIZE
+            for phrase, key_hex, addr in hits:
+                print(f"\n✅ MATCH: {phrase}\n   priv: {key_hex}\n   addr: {addr}\n")
+                matches.append((phrase, key_hex, addr))
+                with open(MATCHED_FILE, "a", encoding="utf-8") as f:
+                    f.write(f"{phrase} | {key_hex} | {addr}\n")
+
+            now = time.time()
+            if now - last_log >= 2:
+                elapsed = now - start
+                rate = done / elapsed if elapsed else 0
+                eta = (total - done) / rate if rate else 0
+                print(f"  ...{done:,}/{total:,} ({100*done/total:.2f}%) ETA {eta/60:.1f}min")
+                last_log = now
+
+    elapsed = time.time() - start
+    print(f"\nDone {elapsed:.1f}s. {len(matches)} match(es).")
+
+if __name__ == "__main__":
+    main()