Create app.py

app.py

@@ -0,0 +1,251 @@
+import os
+import time
+import hashlib
+import hmac
+import sys
+import multiprocessing
+from mnemonic import Mnemonic
+import coincurve
+from eth_utils import keccak, to_checksum_address
+from web3 import Web3
+
+# ============================================================
+# 🛠️ APNI SETTINGS YAHAN SET KAREIN
+# ============================================================
+CSV_FILE = "14262022_addresses.csv"      
+
+# ✅ Yahan apni test phrase dalein (jo 25th number par aayegi)
+MY_TEST_PHRASE = "lesson cushion crane affair federal decline limb spend reunion chief cart zebra"
+
+NUM_PHRASES = 5000         
+SCAN_MODE = "File"       
+ACC_START = 0
+ACC_END = 29
+ADDR_START = 0
+ADDR_END = 29
+SHOW_ALL = False
+PASSPHRASE = ""
+
+# ✅ Your system has 192 logical cores. 190 workers is the sweet spot.
+NUM_WORKERS = 192        
+# ============================================================
+
+# Web3 Setup
+alchemy_api_key = "Rjey8KWIGjKik1qfZ4vdU"
+alchemy_url = f"https://eth-mainnet.g.alchemy.com/v2/{alchemy_api_key}"
+web3_eth = Web3(Web3.HTTPProvider(alchemy_url, request_kwargs={"timeout": 10}))
+bsc_url = "https://bsc-dataseed.binance.org/"
+web3_bsc = Web3(Web3.HTTPProvider(bsc_url, request_kwargs={"timeout": 10}))
+
+def get_balances(address):
+    eth_float, bnb_float = 0.0, 0.0
+    eth_str, bnb_str = "0.0", "0.0"
+    try:
+        eth_wei = web3_eth.eth.get_balance(Web3.to_checksum_address(address))
+        eth_float = float(Web3.from_wei(eth_wei, 'ether'))
+        if eth_float > 0: eth_str = f"{eth_float:.6f}"
+    except Exception: pass
+    try:
+        bnb_wei = web3_bsc.eth.get_balance(Web3.to_checksum_address(address))
+        bnb_float = float(Web3.from_wei(bnb_wei, 'ether'))
+        if bnb_float > 0: bnb_str = f"{bnb_float:.6f}"
+    except Exception: pass
+    return eth_float, bnb_float, eth_str, bnb_str
+
+# ============================================================
+# Global Variables for Workers (Shared via Linux Fork)
+# ============================================================
+KNOWN_ADDRESSES = None
+_MNEMONIC = None
+
+def init_worker(known_addresses):
+    global KNOWN_ADDRESSES
+    KNOWN_ADDRESSES = known_addresses
+    _get_mnemonic()
+
+def _get_mnemonic():
+    global _MNEMONIC
+    if _MNEMONIC is None: _MNEMONIC = Mnemonic("english")
+    return _MNEMONIC
+
+# ============================================================
+# Crypto Logic
+# ============================================================
+_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, account_idx=0, address_idx=0):
+    I = hmac.new(b"Bitcoin seed", seed, hashlib.sha512).digest()
+    key, chain = I[:32], I[32:]
+    for idx in [44 + _HARDENED, 60 + _HARDENED, account_idx + _HARDENED, 0, address_idx]:
+        key, chain = _bip32_derive_child_priv(key, chain, idx)
+    return key
+
+def phrase_to_seed(phrase, passphrase=""):
+    return _get_mnemonic().to_seed(phrase, passphrase=passphrase)
+
+# ============================================================
+# Worker Function (Yeh 190 cores par parallel chalega)
+# ============================================================
+def process_phrase_worker(phrase):
+    global KNOWN_ADDRESSES
+    seed = phrase_to_seed(phrase, PASSPHRASE)
+    matches_found = []
+    paths_checked = 0
+
+    for acc_idx in range(ACC_START, ACC_END + 1):
+        for addr_idx in range(ADDR_START, ADDR_END + 1):
+            paths_checked += 1
+            try:
+                priv = seed_to_privkey_hd(seed, acc_idx, addr_idx)
+                pub = coincurve.PrivateKey(priv).public_key.format(compressed=False)[1:]
+                addr = to_checksum_address(keccak(pub)[-20:])
+            except Exception:
+                continue
+
+            if SCAN_MODE == "File":
+                norm_addr = addr[2:].lower() if addr.startswith("0x") else addr.lower()
+                
+                if norm_addr in KNOWN_ADDRESSES:
+                    match_details = (
+                        f"\n{'🎯'*20}\n"
+                        f"🎯 FILE MATCH FOUND!\n"
+                        f"Phrase:      {phrase}\n"
+                        f"Path:        m/44'/60'/{acc_idx}'/0/{addr_idx}\n"
+                        f"Private Key: {priv.hex()}\n"
+                        f"Address:     {addr}\n"
+                        f"{'🎯'*20}\n"
+                    )
+                    matches_found.append(match_details)
+
+            else: 
+                eth_float, bnb_float, eth_str, bnb_str = get_balances(addr)
+                if eth_float > 0 or bnb_float > 0:
+                    match_details = (
+                        f"\n{'🎉'*20}\n"
+                        f"🎉 MATCH WITH BALANCE!\n"
+                        f"Phrase:      {phrase}\n"
+                        f"Path:        m/44'/60'/{acc_idx}'/0/{addr_idx}\n"
+                        f"Private Key: {priv.hex()}\n"
+                        f"Address:     {addr}\n"
+                        f"ETH:         {eth_str}\n"
+                        f"BNB:         {bnb_str}\n"
+                        f"{'🎉'*20}\n"
+                    )
+                    matches_found.append(match_details)
+
+    return paths_checked, matches_found
+
+# ============================================================
+# CSV File Setup
+# ============================================================
+def load_addresses_from_csv(path):
+    if not os.path.exists(path): return None
+    print(f"⏳ Loading CSV: {path}")
+    start = time.time()
+    
+    addresses = set()
+    with open(path, "r", encoding="utf-8", errors="replace") 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:
+                addresses.add(a)
+    
+    elapsed = time.time() - start
+    print(f"✅ Loaded {len(addresses):,} addresses in {elapsed:.1f} seconds.\n")
+    return addresses
+
+# ============================================================
+# Main
+# ============================================================
+def main():
+    global_start = time.time()
+
+    known_addresses = None
+    if SCAN_MODE == "File":
+        known_addresses = load_addresses_from_csv(CSV_FILE)
+        if not known_addresses:
+            print(f"❌ CSV File nahi mili ya khali hai: {CSV_FILE}")
+            return
+
+    print("=" * 60)
+    print(f"🔍 HD Wallet Scanner (Parallel: {NUM_WORKERS} Cores)")
+    print("=" * 60)
+    print(f"🛠️ Scan Mode: {SCAN_MODE} | Account: {ACC_START}-{ACC_END} | Address: {ADDR_START}-{ADDR_END}")
+    print(f"📝 Total Phrases to scan: {NUM_PHRASES}\n")
+
+    mnemo = _get_mnemonic()
+    
+    # Phrase list generate karein
+    phrases_to_check = []
+    for i in range(1, NUM_PHRASES + 1):
+        if i == 25:
+            phrases_to_check.append(MY_TEST_PHRASE)
+        else:
+            phrases_to_check.append(mnemo.generate(strength=128))
+
+    total_phrases = len(phrases_to_check)
+    phrases_checked = 0
+    total_paths_checked = 0
+    total_matches = 0
+
+    def update_progress(completed, total):
+        pct = (completed / total) * 100
+        sys.stdout.write(f"\r⏳ Scanning Progress: {pct:.1f}% ({completed}/{total})")
+        sys.stdout.flush()
+
+    print(f"🚀 Starting {NUM_WORKERS} workers on your Dual-Socket Xeon...\n")
+
+    try:
+        # Linux fork will share the 1.5GB address set across all 190 workers!
+        with multiprocessing.Pool(
+            processes=NUM_WORKERS, 
+            initializer=init_worker, 
+            initargs=(known_addresses,)
+        ) as pool:
+            
+            # chunksize=2 distributes work rapidly across both NUMA nodes
+            for paths, matches in pool.imap_unordered(process_phrase_worker, phrases_to_check, chunksize=2):
+                phrases_checked += 1
+                total_paths_checked += paths
+                
+                for match in matches:
+                    print(match)
+                    total_matches += 1
+                
+                update_progress(phrases_checked, total_phrases)
+
+        print()
+            
+    except KeyboardInterrupt:
+        print("\n\n🛑 Script ruk gayi (Ctrl+C).")
+        pool.terminate()
+        pool.join()
+    
+    global_elapsed = time.time() - global_start
+
+    print("\n" + "=" * 60)
+    print("🏁 RUN SUMMARY")
+    print("=" * 60)
+    print(f"📝 Phrases checked in THIS run:          {phrases_checked}")
+    print(f"🔑 Private Keys generated in THIS run:   {total_paths_checked:,}")
+    print(f"📬 Addresses checked in THIS run:        {total_paths_checked:,}")
+    print(f"🎯 Matches found in THIS run:            {total_matches}")
+    print("-" * 60)
+    print(f"⏱️ Total time to complete process:       {global_elapsed:.2f} seconds")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()