Update app.py

app.py

@@ -1,213 +1,55 @@
-from itertools import permutations, combinations
-import hashlib, hmac, os, time, math, gc
-from multiprocessing import Pool
+# debug_which.py
+from mnemonic import Mnemonic
 from eth_account import Account
-import coincurve
 from eth_utils import keccak, to_checksum_address
-
-# ============================================================
-words = [
-    "lesson", "cushion", "crane", "affair", "federal",
-    "decline", "limb", "spend", "reunion", "chief", "cart", "zebra",
-]
-
-PHRASE_MODE = "order"
-USE_BIP39   = True
-BIP39_PASSPHRASE = ""
-HD_DERIVATION = True
-ADDRESS_INDEX = 0
-CHECK_BIP39_CHECKSUM = False    # ✅ prefilter off — speed 16x
-ADDRESSES_FILE = "12730802_addresses.csv"
-MATCHED_FILE   = f"matched_keys_{PHRASE_MODE}.txt"
-BATCH_SIZE  = 5000
-NUM_WORKERS = 48
-CHUNK_SIZE  = 4
-# ============================================================
-
-# ---------- secp256k1 ----------
-_SECP256K1_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
-_HARDENED    = 0x80000000
-
-def _bip32_derive_child_priv(parent_priv, parent_chain, index):
-    if index >= _HARDENED:
-        data = b'\x00' + parent_priv + index.to_bytes(4, 'big')
+import coincurve, hmac, hashlib
+
+Account.enable_unaudited_hdwallet_features()
+phrase = "lesson cushion crane affair federal decline limb spend reunion chief cart zebra"
+TARGET = "0x3f0482fc3e9132c3d3acb5f588e980d7b3a5af07"
+
+# --- Manual BIP32 (aapke code se) ---
+_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+_H = 0x80000000
+def _child(priv, chain, i):
+    if i >= _H:
+        data = b'\x00' + priv + i.to_bytes(4, 'big')
     else:
-        pub = coincurve.PrivateKey(parent_priv).public_key.format(compressed=True)
-        data = pub + index.to_bytes(4, 'big')
-    I = hmac.new(parent_chain, data, hashlib.sha512).digest()
-    child_int = (int.from_bytes(I[:32], 'big') + int.from_bytes(parent_priv, 'big')) % _SECP256K1_N
-    if child_int == 0:
-        raise ValueError("Invalid child key")
-    return child_int.to_bytes(32, 'big'), I[32:]
+        pub = coincurve.PrivateKey(priv).public_key.format(compressed=True)
+        data = pub + i.to_bytes(4, 'big')
+    I = hmac.new(chain, data, hashlib.sha512).digest()
+    ki = (int.from_bytes(I[:32], 'big') + int.from_bytes(priv, 'big')) % _N
+    return ki.to_bytes(32, 'big'), I[32:]
 
-def seed_to_privkey_hd(seed, address_index=0):
+def seed_to_privkey_hd(seed, idx=0):
     I = hmac.new(b"Bitcoin seed", seed, hashlib.sha512).digest()
     key, chain = I[:32], I[32:]
-    path = [44 + _HARDENED, 60 + _HARDENED, _HARDENED, 0, address_index]
-    for idx in path:
-        key, chain = _bip32_derive_child_priv(key, chain, idx)
+    for i in [44+_H, 60+_H, _H, 0, idx]:
+        key, chain = _child(key, chain, i)
     return key
 
-# ---------- 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(phrase):
-    """Rust check_phrase (fast) ya Python mnemonic.check()."""
-    if _USE_RUST_BIP39:
-        return _bip39_rust.check_phrase(phrase)
-    return _get_mnemonic().check(phrase)
-
-def phrase_to_seed(phrase):
-    """✅ Rust phrase_to_seed (fast) — sahi function name."""
-    if _USE_RUST_BIP39:
-        return _bip39_rust.phrase_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()
-
-def process_batch(batch):
-    hits = []
-    known = _KNOWN
-    for phrase in batch:
-        if CHECK_BIP39_CHECKSUM and not is_valid_bip39(phrase):
-            continue
-        try:
-            seed = phrase_to_seed(phrase)                    # ✅ Rust phrase_to_seed
-            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:
-            continue
-        if normalize(addr) in known:
-            hits.append((phrase, priv.hex(), addr))
-    return hits
-
-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})")
-    print(f"Checksum prefilter: {CHECK_BIP39_CHECKSUM}")
-    print(f"Rust BIP39: {_USE_RUST_BIP39}\n")
-
-    known = load_addresses(ADDRESSES_FILE)
-    print(f"Loaded {len(known):,} addresses\n")
-
-    matches = []
-    done = 0
-    start = time.time()
-    last_log = start
-
-    with open(MATCHED_FILE, "w", encoding="utf-8") as f:
-        f.write("")
-
-    gc.collect()
-    gc.freeze()
-
-    with Pool(processes=NUM_WORKERS,
-              initializer=init_worker,
-              initargs=(known,)) as pool:
-        for hits in pool.imap_unordered(process_batch, batch_generator(), chunksize=CHUNK_SIZE):
-            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")
-                    f.flush()
-                    os.fsync(f.fileno())
-
-            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}%)  "
-                      f"{rate:,.0f}/s  ETA {eta/60:.1f}min")
-                last_log = now
-
-    elapsed = time.time() - start
-    print(f"\nDone {elapsed/60:.2f} min. {len(matches)} match(es).")
-    if matches:
-        print(f"Results: {MATCHED_FILE}")
-
-
-if __name__ == "__main__":
-    main()
+# --- Test 1: Python mnemonic seed + manual BIP32 ---
+seed_py = Mnemonic("english").to_seed(phrase, "")
+priv_py = seed_to_privkey_hd(seed_py, 0)
+pub = coincurve.PrivateKey(priv_py).public_key.format(compressed=False)[1:]
+addr_manual = to_checksum_address(keccak(pub)[-20:])
+
+# --- Test 2: bip39 (Rust/Python) seed + manual BIP32 ---
+import bip39
+seed_rust = bip39.phrase_to_seed(phrase, "")
+priv_rust = seed_to_privkey_hd(seed_rust, 0)
+pub2 = coincurve.PrivateKey(priv_rust).public_key.format(compressed=False)[1:]
+addr_rust = to_checksum_address(keccak(pub2)[-20:])
+
+# --- Test 3: eth_account ---
+acct = Account.from_mnemonic(phrase, account_path="m/44'/60'/0'/0/0")
+
+print(f"Manual(Python seed): {addr_manual}")
+print(f"Manual(Rust seed):   {addr_rust}")
+print(f"eth_account:         {acct.address}")
+print(f"Target:              {TARGET}")
+print()
+print(f"Manual(Python) == Target: {addr_manual.lower() == TARGET}")
+print(f"Manual(Rust) == Target:   {addr_rust.lower() == TARGET}")
+print(f"eth_account == Target:    {acct.address.lower() == TARGET}")
+print(f"Manual(Python) == eth_account: {addr_manual.lower() == acct.address.lower()}")