Create app.py

app.py

@@ -0,0 +1,300 @@
+import asyncio
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=RuntimeWarning)
+
+try:
+    asyncio.set_event_loop(asyncio.new_event_loop())
+except Exception:
+    pass
+
+import gradio as gr
+import hashlib, hmac, os, time, math, random, gc
+from itertools import permutations, combinations
+from mnemonic import Mnemonic
+import coincurve
+from eth_utils import keccak, to_checksum_address
+import spaces
+
+@spaces.GPU
+def _noop():
+    return "ok"
+
+# ============================================================
+_MNEMONIC = None
+def _get_mnemonic():
+    global _MNEMONIC
+    if _MNEMONIC is None:
+        _MNEMONIC = Mnemonic("english")
+    return _MNEMONIC
+
+# ---------- BIP32 manual ----------
+_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')
+    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:]
+
+def seed_to_privkey_hd(seed, address_index=0):
+    I = hmac.new(b"Bitcoin seed", seed, hashlib.sha512).digest()
+    key, chain = I[:32], I[32:]
+    for idx in [44 + _HARDENED, 60 + _HARDENED, _HARDENED, 0, address_index]:
+        key, chain = _bip32_derive_child_priv(key, chain, idx)
+    return key
+
+# ---------- BIP39 ----------
+try:
+    import bip39 as _bip39_rust
+    _USE_RUST_BIP39 = True
+    if hasattr(_bip39_rust, 'phrase_to_seed'):
+        _seed_fn = _bip39_rust.phrase_to_seed
+        _check_fn = getattr(_bip39_rust, 'check_phrase', None)
+    elif hasattr(_bip39_rust, 'bip39_to_seed'):
+        _seed_fn = _bip39_rust.bip39_to_seed
+        _check_fn = getattr(_bip39_rust, 'bip39_validate', None)
+    else:
+        _seed_fn = None; _check_fn = None; _USE_RUST_BIP39 = False
+except ImportError:
+    _bip39_rust = None; _USE_RUST_BIP39 = False; _seed_fn = None; _check_fn = None
+
+def is_valid_bip39(phrase):
+    if _USE_RUST_BIP39 and _check_fn:
+        return _check_fn(phrase)
+    return _get_mnemonic().check(phrase)
+
+def phrase_to_seed(phrase, passphrase=""):
+    if _USE_RUST_BIP39 and _seed_fn:
+        return _seed_fn(phrase, passphrase)
+    return _get_mnemonic().to_seed(phrase, passphrase=passphrase)
+
+# ---------- Address Cache ----------
+_ADDRESS_CACHE = {}
+
+def load_addresses_cached(path):
+    if path in _ADDRESS_CACHE:
+        cached_mtime, cached_set = _ADDRESS_CACHE[path]
+        try:
+            current_mtime = os.path.getmtime(path)
+            if current_mtime == cached_mtime:
+                return cached_set
+        except OSError:
+            pass
+
+    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)
+
+    try:
+        mtime = os.path.getmtime(path)
+    except OSError:
+        mtime = 0
+    _ADDRESS_CACHE[path] = (mtime, s)
+    return s
+
+def normalize(addr):
+    a = addr.strip().lower()
+    if a.startswith("0x"):
+        a = a[2:]
+    return a
+
+# ---------- Generator ----------
+def generate_phrases_for_words(wordlist, mode):
+    n = len(wordlist)
+    if mode == "order":
+        for perm in permutations(wordlist):
+            yield " ".join(perm)
+    elif mode == "replace":
+        for i in range(n):
+            for w in wordlist:
+                new = wordlist.copy()
+                new[i] = w
+                yield " ".join(new)
+    elif mode == "subset":
+        for r in range(1, n + 1):
+            for combo in combinations(wordlist, r):
+                yield " ".join(combo)
+
+# ============================================================
+# Gradio functions
+# ============================================================
+
+def generate_random_phrase():
+    return _get_mnemonic().generate(strength=128)
+
+
+def run_multi_phrase_scan(num_phrases, addresses_file, phrase_mode,
+                          start_index, end_index, passphrase):
+    """
+    User se poocha gaya number of phrases generate karta hai,
+    phir ek ek karke scan karta hai.
+    """
+    if not os.path.exists(addresses_file):
+        return f"❌ File nahi mili: {addresses_file}", ""
+
+    num_phrases = int(num_phrases)
+    if num_phrases < 1:
+        return "❌ Kam az kam 1 phrase chahiye", ""
+
+    start_index = int(start_index)
+    end_index = int(end_index)
+    if start_index > end_index:
+        return "❌ Start index end index se bada nahi ho sakta", ""
+
+    try:
+        known = load_addresses_cached(addresses_file)
+    except Exception as e:
+        return f"❌ Addresses load fail: {e}", ""
+
+    if not known:
+        return "❌ Koi valid address file mein nahi mila", ""
+
+    # Generate phrases
+    mnemo = _get_mnemonic()
+    phrases = [mnemo.generate(strength=128) for _ in range(num_phrases)]
+
+    log_lines = [
+        f"✅ Loaded {len(known):,} addresses (cached)",
+        f"🔧 Mode: {phrase_mode}",
+        f"🔑 Index range: {start_index}–{end_index}",
+        f"📝 Phrases to check: {num_phrases}",
+        "",
+        "Generated phrases:",
+    ]
+    for i, p in enumerate(phrases, 1):
+        log_lines.append(f"  {i}. {p}")
+    log_lines.append("")
+
+    matches = []
+    start = time.time()
+
+    for p_idx, phrase in enumerate(phrases, 1):
+        log_lines.append(f"🔍 [{p_idx}/{num_phrases}] Checking: {phrase}")
+        words = phrase.strip().split()
+        if len(words) != 12:
+            log_lines.append(f"   ⚠️ Skipped (not 12 words)")
+            continue
+
+        for idx in range(start_index, end_index + 1):
+            for phrase_str in generate_phrases_for_words(words, phrase_mode):
+                if not is_valid_bip39(phrase_str):
+                    continue
+                try:
+                    seed = phrase_to_seed(phrase_str, passphrase)
+                    priv = seed_to_privkey_hd(seed, idx)
+                    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:
+                    match_line = (
+                        f"🎉 MATCH!\n"
+                        f"Phrase: {phrase_str}\n"
+                        f"Index:  {idx}\n"
+                        f"Key:    {priv.hex()}\n"
+                        f"Addr:   {addr}\n"
+                    )
+                    log_lines.append(match_line)
+                    matches.append((phrase_str, idx, priv.hex(), addr))
+
+    elapsed = time.time() - start
+    log_lines.append(f"=== DONE ===")
+    log_lines.append(f"Total time: {elapsed:.1f}s")
+    log_lines.append(f"Total matches: {len(matches)}")
+
+    matches_text = "\n".join(
+        f"Phrase: {p}\nIndex: {i}\nKey: {k}\nAddr: {a}\n" for p, i, k, a in matches
+    ) if matches else "Koi match nahi mila"
+
+    return "\n".join(log_lines), matches_text
+
+
+# ============================================================
+# Build UI
+# ============================================================
+with gr.Blocks(title="Phrase Scanner") as demo:
+    gr.Markdown("# 🔍 Phrase Scanner")
+    gr.Markdown("Kitni random phrases check karni hain? Phir index range ke saath scan karein.")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Settings")
+            num_phrases = gr.Number(
+                label="Kitni Random Phrases Check Karein?",
+                value=10, precision=0, minimum=1,
+            )
+            addresses_file = gr.Textbox(
+                label="Addresses File",
+                value="12730802_addresses.csv",
+            )
+            phrase_mode = gr.Radio(
+                choices=["replace", "order", "subset"],
+                value="replace",
+                label="Phrase Mode",
+            )
+            with gr.Row():
+                start_index = gr.Number(
+                    label="Start Index",
+                    value=0, precision=0, minimum=0,
+                )
+                end_index = gr.Number(
+                    label="End Index",
+                    value=20, precision=0, minimum=0,
+                )
+            passphrase = gr.Textbox(
+                label="BIP39 Passphrase (khali chhod dein)",
+                value="",
+                type="password",
+            )
+            run_btn = gr.Button("🚀 Scan Shuru Karein", variant="primary")
+
+        with gr.Column(scale=2):
+            gr.Markdown("### Output")
+            log_output = gr.Textbox(
+                label="Scan Log",
+                lines=20,
+                max_lines=30,
+                interactive=False,
+                autoscroll=True,
+            )
+            matches_output = gr.Textbox(
+                label="Matches",
+                lines=10,
+                interactive=False,
+                autoscroll=True,
+            )
+
+    run_btn.click(
+        fn=run_multi_phrase_scan,
+        inputs=[num_phrases, addresses_file, phrase_mode,
+                start_index, end_index, passphrase],
+        outputs=[log_output, matches_output],
+    )
+
+# ZeroGPU requirement
+_noop()
+
+_original_launch = demo.launch
+def _patched_launch(**kwargs):
+    kwargs.setdefault("ssr_mode", False)
+    kwargs.setdefault("share", True)
+    kwargs.setdefault("server_name", "0.0.0.0")
+    kwargs.setdefault("server_port", 7860)
+    return _original_launch(**kwargs)
+demo.launch = _patched_launch
+
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft())