Update app.py

app.py

@@ -1,33 +1,305 @@
-with gr.Row():
-    my_phrase = gr.Textbox(
-        label="Your Phrase (optional)",
-        value="lesson cushion crane affair federal decline limb spend reunion chief cart zebra",
-        lines=2
+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, gc, random
+from itertools import permutations, combinations
+from multiprocessing import Pool
+from mnemonic import Mnemonic
+import coincurve
+from eth_utils import keccak, to_checksum_address
+import spaces
+
+# ============================================================
+# 🔑 APNI PHRASE YAHAN DALEIN
+MY_PHRASE = "lesson cushion crane affair federal decline limb spend reunion chief cart zebra"
+# ============================================================
+
+@spaces.GPU
+def _noop():
+    return "ok"
+
+# ---------- Mnemonic ----------
+_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 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_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)
+
+# ---------- Worker ----------
+_KNOWN = None
+
+def init_worker(known):
+    global _KNOWN
+    _KNOWN = known
+    _get_mnemonic()
+
+def process_batch(args):
+    batch, passphrase, address_index, hd, checksum = args
+    hits = []
+    known = _KNOWN
+    for phrase in batch:
+        if checksum and not is_valid_bip39(phrase):
+            continue
+        try:
+            seed = phrase_to_seed(phrase, passphrase)
+            priv = seed_to_privkey_hd(seed, address_index) if hd else 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_for_words(wordlist, mode, batch_size):
+    batch = []
+    for phrase in generate_phrases_for_words(wordlist, mode):
+        batch.append(phrase)
+        if len(batch) >= batch_size:
+            yield batch
+            batch = []
+    if batch:
+        yield batch
+
+# ============================================================
+# Gradio Interface
+# ============================================================
+def run_scan(
+    my_phrase,
+    addresses_file,
+    num_phrases,
+    phrase_mode,
+    address_index,
+    passphrase,
+    workers,
+    batch_size,
+    progress=gr.Progress(),
+):
+    if not os.path.exists(addresses_file):
+        return f"❌ File nahi mili: {addresses_file}", ""
+
+    num_phrases = int(num_phrases)
+    workers = int(workers)
+    batch_size = int(batch_size)
+    address_index = int(address_index)
+
+    if num_phrases < 0:
+        return "❌ Phrases ki tadaad negative nahi ho sakti", ""
+    if workers < 1:
+        return "❌ Kam az kam 1 worker chahiye", ""
+
+    yield "Addresses load ho rahe hain...", ""
+    try:
+        known = load_addresses(addresses_file)
+    except Exception as e:
+        return f"❌ Addresses load fail: {e}", ""
+
+    if not known:
+        return "❌ Koi valid address file mein nahi mila", ""
+
+    wordlist = _get_mnemonic().wordlist
+    random_phrases = [random.sample(wordlist, 12) for _ in range(num_phrases)]
+
+    # 🔑 Apni phrase sab se pehle
+    my_words = my_phrase.strip().split()
+    if len(my_words) == 12:
+        random_phrases.insert(0, my_words)
+        phrase_note = "✅ Aapki phrase sab se pehle check hogi"
+    else:
+        phrase_note = f"⚠️ Aapki phrase 12 words ki nahi hai ({len(my_words)} words) — skip"
+
+    total_phrases = len(random_phrases)
+    log_lines = [
+        phrase_note,
+        f"✅ Loaded {len(known):,} addresses",
+        f"✅ {num_phrases} random phrases + 1 aapki phrase = {total_phrases} total",
+        f"🔧 Mode: {phrase_mode} | Workers: {workers} | Batch: {batch_size}",
+        f"🔑 Address index: {address_index} | Passphrase: {'(set)' if passphrase else '(empty)'}",
+        "",
+    ]
+
+    output_matches = []
+    matches_text = ""
+    all_start = time.time()
+
+    for idx, wordlist_words in enumerate(random_phrases, 1):
+        progress((idx - 1) / total_phrases, desc=f"Phrase {idx}/{total_phrases}")
+
+        gc.collect()
+        gc.freeze()
+
+        phrase_matches = []
+
+        with Pool(processes=workers,
+                  initializer=init_worker,
+                  initargs=(known,)) as pool:
+            for hits in pool.imap_unordered(
+                process_batch,
+                (
+                    (batch, passphrase, address_index, True, True)
+                    for batch in batch_generator_for_words(wordlist_words, phrase_mode, batch_size)
+                ),
+                chunksize=4
+            ):
+                for phrase, key_hex, addr in hits:
+                    match_line = f"🎉 MATCH!\nPhrase: {phrase}\nKey:    {key_hex}\nAddr:   {addr}\n"
+                    matches_text += match_line + "\n"
+                    output_matches.append((phrase, key_hex, addr))
+                    phrase_matches.append((phrase, key_hex, addr))
+                    log_lines.append(match_line)
+                    yield "\n".join(log_lines), matches_text
+
+        log_lines.append(f"Phrase {idx}/{total_phrases} done — {len(phrase_matches)} match(es)")
+        yield "\n".join(log_lines), matches_text
+
+    elapsed = time.time() - all_start
+    progress(1.0, desc="Done")
+    log_lines.append("")
+    log_lines.append(f"=== DONE ===")
+    log_lines.append(f"Total time: {elapsed:.1f}s")
+    log_lines.append(f"Total matches: {len(output_matches)}")
+
+    yield "\n".join(log_lines), matches_text
+
+
+# ============================================================
+# Build UI
+# ============================================================
+with gr.Blocks(title="Phrase Scanner") as demo:
+    gr.Markdown("# 🔍 Phrase Scanner")
+    gr.Markdown("Aapki phrase + random 12-word phrases generate karein aur address file se match karein.")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Settings")
+            my_phrase = gr.Textbox(
+                label="🔑 Aapki Phrase (12 words)",
+                value=MY_PHRASE,
+                placeholder="lesson cushion crane ...",
+                lines=2,
+            )
+            addresses_file = gr.Textbox(label="Addresses File", value="12730802_addresses.csv")
+            num_phrases = gr.Slider(label="Kitni Random Phrases", minimum=0, maximum=1000, value=10, step=1)
+            phrase_mode = gr.Radio(choices=["replace", "order", "subset"], value="replace", label="Phrase Mode")
+            address_index = gr.Number(label="Address Index", value=0, precision=0)
+            passphrase = gr.Textbox(label="BIP39 Passphrase (khali chhod dein)", value="", type="password")
+            workers = gr.Slider(label="Workers", minimum=1, maximum=192, value=48, step=1)
+            batch_size = gr.Slider(label="Batch Size", minimum=100, maximum=10000, value=5000, step=100)
+            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_scan,
+        inputs=[my_phrase, addresses_file, num_phrases, phrase_mode,
+                address_index, passphrase, workers, batch_size],
+        outputs=[log_output, matches_output],
     )
-    
-with gr.Row():
-    num_phrases = gr.Number(label="Random Phrases to Check", value=10, minimum=0)
-    addresses_file = gr.Textbox(label="Addresses File", value="12730802_addresses.csv")
-
-with gr.Row():
-    phrase_mode = gr.Radio(choices=["replace", "order", "subset"], value="replace", label="Phrase Mode")
-    start_index = gr.Number(label="Start Index", value=0, minimum=0)
-    end_index = gr.Number(label="End Index", value=20, minimum=0)
-    
-with gr.Row():
-    passphrase = gr.Textbox(label="BIP39 Passphrase", value="", type="password")
-    
-run_btn = gr.Button("🚀 Start Scan", variant="primary")
-
-gr.Markdown("### Output")
-log_output = gr.Textbox(lines=15, interactive=False, show_label=False)
-
-gr.Markdown("### Matches")
-matches_output = gr.Textbox(lines=8, interactive=False, show_label=False)
-
-run_btn.click(
-    fn=run_scan,
-    inputs=[my_phrase, num_phrases, addresses_file, phrase_mode,
-            start_index, end_index, passphrase],
-    outputs=[log_output, matches_output]
-)
+
+# ZeroGPU requirement
+_noop()
+
+# ✅ SSR off + share for health check
+_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())