Upload 16 files

check/.gitignore

@@ -0,0 +1,112 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

check/.local/state/replit/agent/.agent_state_3f44dea3ced50eea70ed33f619266e6106de2f11.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:348dc2a73d8391d49ef77ec716b2f92e2e9024fa39cc984cebac680c8ce7763c
+size 70772

check/.local/state/replit/agent/.agent_state_463c51dcb980c6a1c74871fdded99cee48599e9f.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e385906b8811e52a23cb2e70c96e9dc0f3e17fdae5693a8117a2cebbaed9610
+size 15354

check/.local/state/replit/agent/.agent_state_4a9c459c1a931955b949bf88f4b0e0baa9962553.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1117e7acff36469b266910d8ddc0c9706f8199b05c142914aa83266beed87f74
+size 61030

check/.local/state/replit/agent/.agent_state_64e054bde1467c40837361c152fc18d8c61c7222.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0043f982a8790ee22f682f758e4c3ae332c9e9ef5e4224a332d8a74d427c784
+size 43283

check/.local/state/replit/agent/.agent_state_8e004c6c49565a75b7faeecd2d322a680a4f0544.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1224d68482e0e6252197eadc9bfea4a199ec50bb010a27df78001d58a5c0aad3
+size 53225

check/.local/state/replit/agent/.agent_state_a142ae0b26554e72877f8744d1805d558482e490.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c42c1cc3765aeaf52cfe3c4e2dda77a0d55dd1bc552a8fa1a2be89783ea81633
+size 15324

check/.local/state/replit/agent/.agent_state_main.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9eef0a119374324445ed18e6bc52dad353071ac2e61cacaa8eb774ed8595c8b3
+size 70743

check/.local/state/replit/agent/.latest.json

@@ -0,0 +1 @@
+{"latest": "main"}

check/.local/state/replit/agent/filesystem/filesystem_state.json

@@ -0,0 +1 @@
+{"file_contents":{"README.md":{"content":"title: Solana Key-Miner\nemoji: 🪙\ncolorFrom: green\ncolorTo: gray\nsdk: gradio\nsdk_version: 4.44.0\napp_file: app.py\npinned: false\n🔐 Solana Key Generator & Live Miner\nGenerate Ed25519 Base-58 keys and mine Solana addresses in real time with Discord notifications.\n\nFeatures\n🔄 30-minute mining cycles (30 min active, 30 min break)\nNon-stop background miner (100 wallets per RPC call)\nLive Discord status embed (updates every 60 seconds)\n@everyone ping when a funded wallet is found\nReal-time feed inside the interface\nBulk key generation (up to 1000 keys)\nMultiple RPC endpoint fallback for reliability\n🌐 Multi-platform compatibility (Hugging Face Spaces & Replit)\n🚀 Complete Setup Guide for ALL Platforms\n🤗 Hugging Face Spaces (Recommended - FREE)\nStep 1: Create Your Space\nGo to huggingface.co/new-space\nChoose a name for your space (e.g., my-solana-miner)\nSelect Gradio as the SDK\nSet visibility to Public or Private (your choice)\nClick Create Space\nStep 2: Upload Files\nClick Files tab in your new space\nUpload these files from this repository:\napp.py (main application)\nrequirements.txt (dependencies)\nREADME.md (this file)\nStep 3: Set Up Discord (Optional but Recommended)\nGo to your Discord server\nRight-click on the channel where you want notifications\nSelect Edit Channel → Integrations → Webhooks\nClick New Webhook\nCopy the webhook URL\nIn your Hugging Face Space, go to Settings tab\nScroll to Repository secrets\nAdd new secret: DISCORD_WEBHOOK = your_webhook_url_here\nStep 4: Configure Settings (Optional)\nAdd these optional secrets in Hugging Face Settings:\n\nMIN_SOL=0.00001 (minimum SOL to consider \"funded\")\nRPC_BATCH_SIZE=100 (wallets per batch, max 100)\nMINER_SLEEP=1.0 (seconds between mining cycles)\nStep 5: Launch\nYour space will automatically build and deploy\nWait 2-3 minutes for initialization\nClick the app URL to access your miner\nHit Start Mining and watch it work!\n💻 Local Development Setup\nRequirements\nPython 3.8 or higher\nGit\nStep 1: Clone Repository\ngit clone <your-repo-url>\ncd solana-key-miner\nStep 2: Create Virtual Environment\n# Windows\npython -m venv venv\nvenv\\Scripts\\activate\n\n# macOS/Linux\npython3 -m venv venv\nsource venv/bin/activate\nStep 3: Install Dependencies\npip install -r requirements.txt\nStep 4: Set Environment Variables\nCreate a .env file in the project root:\n\n# Required for Discord notifications (optional)\nDISCORD_WEBHOOK=your_discord_webhook_url_here\n\n# Optional settings\nMIN_SOL=0.00001\nRPC_BATCH_SIZE=100\nMINER_SLEEP=1.0\nStep 5: Run the Application\npython app.py\nThe app will be available at http://localhost:7860\n\n🐳 Docker Setup\nStep 1: Create Dockerfile\nCreate Dockerfile in your project root:\n\nFROM python:3.9-slim\n\nWORKDIR /app\nCOPY requirements.txt .\nRUN pip install -r requirements.txt\n\nCOPY . .\n\nEXPOSE 7860\nCMD [\"python\", \"app.py\"]\nStep 2: Build and Run\n# Build the image\ndocker build -t solana-miner .\n\n# Run with environment variables\ndocker run -d \\\n  -p 7860:7860 \\\n  -e DISCORD_WEBHOOK=your_webhook_url \\\n  -e MIN_SOL=0.00001 \\\n  --name solana-miner \\\n  solana-miner\n☁️ Cloud Deployment Options\nGoogle Cloud Run\nInstall Google Cloud CLI\nBuild and deploy:\ngcloud run deploy solana-miner \\\n  --source . \\\n  --platform managed \\\n  --region us-central1 \\\n  --allow-unauthenticated \\\n  --set-env-vars DISCORD_WEBHOOK=your_webhook_url\nAWS EC2\nLaunch Ubuntu 20.04 instance\nSSH into instance\nInstall Python and dependencies:\nsudo apt update\nsudo apt install python3 python3-pip git -y\ngit clone <your-repo>\ncd solana-key-miner\npip3 install -r requirements.txt\nSet environment variables and run\nDigitalOcean Droplet\nCreate Ubuntu droplet\nFollow same steps as AWS EC2\nOptional: Set up nginx reverse proxy\n🔧 Configuration Guide\nEnvironment Variables\nVariable        Default Description\nDISCORD_WEBHOOK None    Discord webhook URL for notifications\nMIN_SOL 0.00001 Minimum SOL to consider wallet \"funded\"\nRPC_BATCH_SIZE  100     Number of wallets to check per RPC call\nMINER_SLEEP     1.0     Seconds to sleep between mining cycles\nPORT    7860    Port for the web interface\nDiscord Setup Details\nServer Permissions: Ensure the bot/webhook has permission to send messages\nChannel Selection: Use a dedicated channel for miner notifications\nWebhook Security: Keep your webhook URL private\nRate Limits: The app automatically manages Discord rate limits\nRPC Endpoints\nThe app uses multiple free Solana RPC endpoints with automatic failover:\n\napi.mainnet-beta.solana.com\nsolana-api.projectserum.com\nrpc.ankr.com/solana\nsolana.public-rpc.com\n🛡️ Security Considerations\nImportant Notes\nThis tool is for educational purposes\nFound private keys are displayed in the interface\nBe cautious when using Discord notifications\nNever share your webhook URLs\nKeep your environment variables secure\nBest Practices\nUse private Hugging Face Spaces for sensitive operations\nRegularly rotate Discord webhooks\nMonitor your RPC usage\nKeep dependencies updated\n📱 Mobile Access\nAccess via Mobile Browser\nDeploy to any cloud platform above\nAccess via mobile browser\nAdd to home screen for app-like experience\nResponsive Design\nThe Gradio interface is mobile-friendly and works on:\n\niPhone (Safari, Chrome)\nAndroid (Chrome, Firefox)\nTablets and iPads\n🔍 Troubleshooting\nCommon Issues\n\"All RPC endpoints failed\"\n\nCheck internet connection\nRPC endpoints may be rate-limiting\nWait a few minutes and try again\nDiscord notifications not working\n\nVerify webhook URL is correct\nCheck channel permissions\nEnsure webhook hasn't been deleted\nApp won't start on Hugging Face\n\nCheck build logs in the space\nVerify all files are uploaded correctly\nEnsure requirements.txt is valid\nHigh memory usage\n\nReduce RPC_BATCH_SIZE to 50 or lower\nRestart the application periodically\nGetting Help\nCheck the build logs first\nVerify all environment variables\nTest with minimal configuration\nCheck Discord webhook with a simple test message\n📊 Performance Optimization\nFor High-Volume Mining\nSet RPC_BATCH_SIZE=100 (maximum)\nUse multiple RPC endpoints\nMonitor rate limits\nConsider using paid RPC services for better performance\nFor Low-Resource Environments\nSet RPC_BATCH_SIZE=25\nIncrease MINER_SLEEP=2.0\nReduce FEED_MAX_ITEMS=25\n🎯 Quick Start Summary\nFastest way to get running:\n\nFork this repository to your GitHub\nCreate Hugging Face Space with Gradio SDK\nUpload files: app.py, requirements.txt, README.md\nAdd Discord webhook (optional) in Space settings\nWait for build (2-3 minutes)\nStart mining and enjoy!\nTotal setup time: 5-10 minutes ⚡\n\nCheck the Hugging Face Spaces documentation for more advanced configuration options.\n","size_bytes":6578},"app.py":{"content":"\"\"\"\nHugging Face Space – Solana Key Generator & Miner\nSimple, reliable implementation optimized for cloud deployment\n\"\"\"\nimport os\nimport queue\nimport threading\nimport time\nimport base58\nimport json\nimport requests\nimport collections\nimport hashlib\nimport secrets\nfrom typing import List, Dict, Optional, Tuple\nfrom datetime import datetime\n\nimport gradio as gr\nfrom solana.rpc.api import Client\nfrom solana.rpc.core import RPCException\nfrom solders.keypair import Keypair\nfrom solders.pubkey import Pubkey\n\n# ---------- Safe keypair generator ----------\ndef _safe_keypair() -> Keypair:\n    \"\"\"Keep drawing 64-byte seeds until Edwards point is valid.\"\"\"\n    while True:\n        try:\n            return Keypair.from_bytes(os.urandom(64))\n        except ValueError:\n            continue\n\n# ---------- Enhanced Console Logger ----------\nimport logging\nlogging.basicConfig(level=logging.INFO, format=\"%(asctime)s  %(message)s\")\nlog = logging.getLogger(\"solana_miner\")\n\n# ---------- Enhanced Configuration with Multi-Miner Support ----------\nclass Config:\n    DISCORD_WEBHOOK = os.getenv(\"DISCORD_WEBHOOK\", \"\")\n    MINER_ID = os.getenv(\"MINER_ID\", f\"Miner-{secrets.token_hex(4)}\")\n    MINER_NAME = os.getenv(\"MINER_NAME\", f\"SolMiner-{secrets.token_hex(3)}\")\n    LOCATION = os.getenv(\"MINER_LOCATION\", \"Unknown\")\n\n    RPC_URLS = [\n        \"https://api.mainnet-beta.solana.com\",\n        \"https://solana-api.projectserum.com\", \n        \"https://rpc.ankr.com/solana\",\n        \"https://solana.public-rpc.com\"\n    ]\n    current_rpc_index = 0\n    MIN_SOL = float(os.getenv(\"MIN_SOL\", \"0.00001\"))\n    RPC_BATCH_SIZE = int(os.getenv(\"RPC_BATCH_SIZE\", \"100\"))\n    MINER_SLEEP = float(os.getenv(\"MINER_SLEEP\", \"1.0\"))\n    MAX_RETRIES = 2\n    FEED_MAX_ITEMS = 50\n\n    # Discord isolation settings\n    DISCORD_RETRY_LIMIT = 3\n    DISCORD_TIMEOUT = 5\n    DISCORD_COOLDOWN = 300  # 5 minutes between reconnect attempts\n\n    @classmethod\n    def get_current_rpc(cls):\n        return cls.RPC_URLS[cls.current_rpc_index]\n\n    @classmethod\n    def rotate_rpc(cls):\n        cls.current_rpc_index = (cls.current_rpc_index + 1) % len(cls.RPC_URLS)\n        log.info(f\"Switched to RPC: {cls.get_current_rpc()}\")\n\nconfig = Config()\n\n# ---------- Advanced Discord Management ----------\nSTATUS_MESSAGE_ID = None\nSTATUS_EDIT_URL = None\nDISCORD_DISABLED = False\nDISCORD_RETRY_COUNT = 0\nDISCORD_LAST_ERROR = None\nDISCORD_LAST_SUCCESS = time.time()\nMINER_START_TIME = datetime.now()\nDISCORD_QUEUE = queue.Queue(maxsize=1000)  # Isolated queue for Discord operations\n\n# ---------- Enhanced Multi-Miner State Management ----------\nclass MinerState:\n    def __init__(self):\n        self.total_mined = 0\n        self.funded_found = 0\n        self.errors_count = 0\n        self.last_funded_time = None\n        self.run_flag = threading.Event()\n        self.upload_queue = queue.Queue()\n        self.lock = threading.Lock()\n\n        # Enhanced tracking\n        self.start_time = datetime.now()\n        self.last_batch_time = None\n        self.current_rpc = None\n        self.rpc_switches = 0\n        self.total_batches = 0\n        self.average_batch_time = 0.0\n        self.best_streak = 0\n        self.current_streak = 0\n        self.wallets_per_second = 0.0\n        self.connection_status = \"Initializing\"\n        self.last_activity = time.time()\n\n        # Performance metrics\n        self.batch_times = collections.deque(maxlen=100)  # Last 100 batch times\n        self.rpc_performance = {}  # Track RPC response times\n        \n        # 30-minute cycle tracking\n        self.cycle_start_time = time.time()\n        self.cycle_active = True\n        self.cycle_break_start = None\n        self.total_cycles = 0\n        self.in_break_mode = False\n\n    def increment_mined(self):\n        with self.lock: \n            self.total_mined += 1\n\n    def increment_errors(self):\n        with self.lock: \n            self.errors_count += 1\n\n    def update_batch_stats(self, batch_size: int, batch_time: float, rpc_url: str):\n        with self.lock:\n            self.last_batch_time = datetime.now()\n            self.total_batches += 1\n            self.batch_times.append(batch_time)\n            self.current_rpc = rpc_url\n            self.last_activity = time.time()\n\n            # Calculate averages\n            if self.batch_times:\n                self.average_batch_time = sum(self.batch_times) / len(self.batch_times)\n                total_time = (datetime.now() - self.start_time).total_seconds()\n                if total_time > 0:\n                    self.wallets_per_second = self.total_mined / total_time\n\n            # Track RPC performance\n            if rpc_url not in self.rpc_performance:\n                self.rpc_performance[rpc_url] = []\n            self.rpc_performance[rpc_url].append(batch_time)\n            if len(self.rpc_performance[rpc_url]) > 50:\n                self.rpc_performance[rpc_url].pop(0)\n\n    def increment_funded(self):\n        with self.lock:\n            self.funded_found += 1\n            self.last_funded_time = datetime.now()\n            self.current_streak += 1\n            if self.current_streak > self.best_streak:\n                self.best_streak = self.current_streak\n\n    def reset_streak(self):\n        with self.lock:\n            self.current_streak = 0\n\n    def get_comprehensive_stats(self) -> Dict:\n        with self.lock:\n            uptime = datetime.now() - self.start_time\n            return {\n                # Basic stats\n                'total_mined': self.total_mined,\n                'funded_found': self.funded_found,\n                'errors_count': self.errors_count,\n                'last_funded': self.last_funded_time,\n                'queue_size': self.upload_queue.qsize(),\n                'is_running': self.run_flag.is_set(),\n\n                # Enhanced stats\n                'miner_id': config.MINER_ID,\n                'miner_name': config.MINER_NAME,\n                'location': config.LOCATION,\n                'start_time': self.start_time,\n                'uptime_seconds': uptime.total_seconds(),\n                'uptime_str': str(uptime).split('.')[0],\n                'current_rpc': self.current_rpc or \"None\",\n                'rpc_switches': self.rpc_switches,\n                'total_batches': self.total_batches,\n                'average_batch_time': round(self.average_batch_time, 2),\n                'wallets_per_second': round(self.wallets_per_second, 2),\n                'best_streak': self.best_streak,\n                'current_streak': self.current_streak,\n                'connection_status': self.connection_status,\n                'last_activity': self.last_activity,\n\n                # 30-minute cycle info\n                'cycle_active': self.cycle_active,\n                'in_break_mode': self.in_break_mode,\n                'total_cycles': self.total_cycles,\n                'cycle_time_remaining': self.get_cycle_time_remaining(),\n\n                # Performance metrics\n                'batch_times_count': len(self.batch_times),\n                'rpc_performance': {rpc: round(sum(times)/len(times), 2) \n                                  for rpc, times in self.rpc_performance.items() if times}\n            }\n\n    def get_cycle_time_remaining(self) -> Dict:\n        \"\"\"Calculate remaining time in current cycle (30 min active / 30 min break)\"\"\"\n        current_time = time.time()\n        cycle_duration = 30 * 60  # 30 minutes in seconds\n        \n        if self.in_break_mode:\n            # In break mode\n            if self.cycle_break_start:\n                elapsed_break = current_time - self.cycle_break_start\n                remaining_break = max(0, cycle_duration - elapsed_break)\n                return {\n                    'mode': 'break',\n                    'remaining_seconds': int(remaining_break),\n                    'remaining_minutes': int(remaining_break / 60),\n                    'progress_percent': min(100, (elapsed_break / cycle_duration) * 100)\n                }\n        else:\n            # In mining mode\n            elapsed_mining = current_time - self.cycle_start_time\n            remaining_mining = max(0, cycle_duration - elapsed_mining)\n            return {\n                'mode': 'mining',\n                'remaining_seconds': int(remaining_mining),\n                'remaining_minutes': int(remaining_mining / 60),\n                'progress_percent': min(100, (elapsed_mining / cycle_duration) * 100)\n            }\n        \n        return {'mode': 'unknown', 'remaining_seconds': 0, 'remaining_minutes': 0, 'progress_percent': 0}\n\n    def check_cycle_status(self) -> bool:\n        \"\"\"Check if we should switch between mining and break mode. Returns True if should continue mining.\"\"\"\n        current_time = time.time()\n        cycle_duration = 30 * 60  # 30 minutes\n        \n        if self.in_break_mode:\n            # Currently in break, check if break time is over\n            if self.cycle_break_start and (current_time - self.cycle_break_start) >= cycle_duration:\n                # Break is over, switch to mining\n                self.in_break_mode = False\n                self.cycle_active = True\n                self.cycle_start_time = current_time\n                self.cycle_break_start = None\n                log.info(\"🟢 30-minute break completed, resuming mining...\")\n                return True\n            return False  # Still in break\n        else:\n            # Currently mining, check if mining time is over\n            if (current_time - self.cycle_start_time) >= cycle_duration:\n                # Mining period is over, switch to break\n                self.in_break_mode = True\n                self.cycle_active = False\n                self.cycle_break_start = current_time\n                self.total_cycles += 1\n                log.info(f\"🔴 30-minute mining cycle #{self.total_cycles} completed, starting 30-minute break...\")\n                return False\n            return True  # Continue mining\n\n    def get_stats(self) -> Dict:\n        # Maintain backward compatibility\n        return self.get_comprehensive_stats()\n\nminer_state = MinerState()\n\n# ---------- Live Feed ----------\nclass LiveFeed:\n    def __init__(self, max_items: int = 100):\n        self.feed = collections.deque(maxlen=max_items)\n        self.lock = threading.Lock()\n\n    def add_entry(self, secret: str, sol: float, address: str = \"\"):\n        with self.lock:\n            timestamp = datetime.now().strftime('%H:%M:%S')\n            if sol >= config.MIN_SOL:\n                entry = f\"🟢 **FUNDED** {sol:.6f} SOL | `{secret[:20]}...` | {address[:20]}... | {timestamp}\"\n                log.info(f\"💰 FUNDED WALLET: {sol:.6f} SOL\")\n            else:\n                entry = f\"🔴 Empty | `{secret[:20]}...` | {timestamp}\"\n            self.feed.append(entry)\n\n    def get_feed(self) -> str:\n        with self.lock: \n            return \"\\n\".join(self.feed)\n\n    def clear_feed(self):\n        with self.lock: \n            self.feed.clear()\n\nlive_feed = LiveFeed(config.FEED_MAX_ITEMS)\n\n# ---------- Key Generation ----------\nBASE58_ALPHABET = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\"\n\ndef generate_secure_keypair() -> Tuple[str, str, Keypair]:\n    \"\"\"Generate a secure keypair with Base58 encoding\"\"\"\n    for attempt in range(1000):\n        try:\n            keypair = _safe_keypair()\n            seed = bytes(keypair)[:32]\n            private_key_b58 = base58.b58encode(seed).decode('utf-8')\n            public_key = str(keypair.pubkey())\n\n            if len(private_key_b58) >= 32 and all(c in BASE58_ALPHABET for c in private_key_b58):\n                return private_key_b58, public_key, keypair\n        except Exception as e:\n            log.warning(f\"Keypair attempt {attempt + 1} failed: {e}\")\n            continue\n    raise Exception(\"Failed to generate valid keypair after 1000 attempts\")\n\ndef get_key_info(private_key: str) -> Dict:\n    try:\n        decoded = base58.b58decode(private_key)\n        keypair = _safe_keypair()\n        return {\n            \"private_key\": private_key,\n            \"public_key\": str(keypair.pubkey()),\n            \"key_length\": len(private_key),\n            \"is_valid\": True,\n            \"private_key_hex\": decoded.hex(),\n            \"public_key_hex\": bytes(keypair.pubkey()).hex(),\n        }\n    except Exception as e:\n        return {\"private_key\": private_key, \"error\": str(e), \"is_valid\": False}\n\n# ---------- Simple Solana Client ----------\ndef create_solana_client() -> Client:\n    \"\"\"Create client with simple RPC rotation\"\"\"\n    for attempt in range(len(config.RPC_URLS)):\n        rpc_url = config.get_current_rpc()\n        try:\n            client = Client(rpc_url.strip())\n            client.get_slot()  # Test connection\n            log.info(f\"✅ Connected to Solana RPC: {rpc_url}\")\n            return client\n        except Exception as e:\n            log.warning(f\"❌ RPC {rpc_url} failed: {e}\")\n            config.rotate_rpc()\n            time.sleep(2)\n\n    raise Exception(\"All RPC endpoints failed\")\n\ndef get_balances_with_retry(client: Client, addresses: List[str]) -> List[float]:\n    \"\"\"Simple balance checking with retry logic\"\"\"\n    chunk_size = min(50, len(addresses))\n\n    for attempt in range(config.MAX_RETRIES):\n        try:\n            all_balances = []\n\n            for i in range(0, len(addresses), chunk_size):\n                chunk = addresses[i:i + chunk_size]\n                pubkeys = [Pubkey.from_string(addr) for addr in chunk]\n\n                time.sleep(0.5)  # Rate limiting\n                resp = client.get_multiple_accounts(pubkeys)\n\n                chunk_balances = []\n                for acc in resp.value:\n                    chunk_balances.append((acc.lamports / 1e9) if acc else 0.0)\n                all_balances.extend(chunk_balances)\n\n                # Small delay between chunks\n                if i + chunk_size < len(addresses):\n                    time.sleep(0.2)\n\n            return all_balances\n\n        except Exception as e:\n            log.warning(f\"Balance check attempt {attempt + 1} failed: {e}\")\n            miner_state.increment_errors()\n            config.rotate_rpc()\n            time.sleep(2)\n\n    return [0.0] * len(addresses)\n\n# ---------- Isolated Discord Operations ----------\ndef queue_discord_message(message_type: str, data: dict):\n    \"\"\"Queue Discord message for isolated processing\"\"\"\n    if not config.DISCORD_WEBHOOK:\n        return\n\n    try:\n        DISCORD_QUEUE.put_nowait({\n            'type': message_type,\n            'data': data,\n            'timestamp': time.time()\n        })\n    except queue.Full:\n        # If queue is full, remove oldest message and add new one\n        try:\n            DISCORD_QUEUE.get_nowait()\n            DISCORD_QUEUE.put_nowait({\n                'type': message_type,\n                'data': data,\n                'timestamp': time.time()\n            })\n        except:\n            pass  # Silently fail to avoid impacting mining\n\ndef send_funded_ping(private_key: str, public_key: str, balance: float):\n    \"\"\"Queue funded wallet notification - never blocks mining\"\"\"\n    stats = miner_state.get_comprehensive_stats()\n    queue_discord_message('funded_wallet', {\n        'private_key': private_key,\n        'public_key': public_key,\n        'balance': balance,\n        'miner_stats': stats,\n        'discovery_time': datetime.now().isoformat()\n    })\n\ndef process_funded_wallet_message(data: dict):\n    \"\"\"Process funded wallet Discord message\"\"\"\n    stats = data['miner_stats']\n    payload = {\n        \"content\": f\"@everyone 🚨 **{stats['miner_name']}** found FUNDED wallet!\",\n        \"embeds\": [{\n            \"title\": f\"💰 FUNDED WALLET DISCOVERED - {stats['miner_name']}\",\n            \"color\": 0x00ff00,\n            \"thumbnail\": {\"url\": \"https://cryptologos.cc/logos/solana-sol-logo.png\"},\n            \"fields\": [\n                {\"name\": \"💼 Wallet Details\", \"value\": \n                 f\"**Balance:** {data['balance']:.8f} SOL\\n\"\n                 f\"**Public Key:** `{data['public_key']}`\\n\"\n                 f\"**Private Key:** ||{data['private_key']}||\", \"inline\": False},\n\n                {\"name\": \"🏆 Miner Performance\", \"value\": \n                 f\"**Total Mined:** {stats['total_mined']:,} wallets\\n\"\n                 f\"**Total Funded:** {stats['funded_found']} wallets\\n\"\n                 f\"**Success Rate:** {(stats['funded_found']/max(stats['total_mined'],1)*100):.6f}%\", \"inline\": True},\n\n                {\"name\": \"⚡ Current Stats\", \"value\": \n                 f\"**Speed:** {stats['wallets_per_second']:.1f} wallets/sec\\n\"\n                 f\"**Uptime:** {stats['uptime_str']}\\n\"\n                 f\"**Current Streak:** {stats['current_streak']}\", \"inline\": True},\n\n                {\"name\": \"🌐 Miner Info\", \"value\": \n                 f\"**ID:** {stats['miner_id']}\\n\"\n                 f\"**Location:** {stats['location']}\\n\"\n                 f\"**RPC:** {stats['current_rpc'].split('//')[-1][:25]}\", \"inline\": True},\n\n                {\"name\": \"📈 Network Stats\", \"value\": \n                 f\"**Batches Processed:** {stats['total_batches']}\\n\"\n                 f\"**Avg Batch Time:** {stats['average_batch_time']}s\\n\"\n                 f\"**RPC Switches:** {stats['rpc_switches']}\", \"inline\": True},\n\n                {\"name\": \"🕒 Discovery Time\", \"value\": f\"<t:{int(time.time())}:F>\", \"inline\": False}\n            ],\n            \"footer\": {\"text\": f\"Miner: {stats['miner_name']} | Best Streak: {stats['best_streak']}\"}\n        }]\n    }\n\n    return requests.post(config.DISCORD_WEBHOOK, data=json.dumps(payload),\n                        headers={\"Content-Type\": \"application/json\"}, \n                        timeout=config.DISCORD_TIMEOUT)\n\ndef queue_status_update():\n    \"\"\"Queue status update - never blocks mining\"\"\"\n    stats = miner_state.get_comprehensive_stats()\n    queue_discord_message('status_update', {\n        'stats': stats,\n        'timestamp': time.time()\n    })\n\ndef process_status_update(data: dict):\n    \"\"\"Process comprehensive status update\"\"\"\n    global STATUS_MESSAGE_ID, STATUS_EDIT_URL\n    stats = data['stats']\n\n    # Enhanced status embed with comprehensive information\n    embed = {\n        \"title\": f\"🪙 {stats['miner_name']} - Live Mining Status\",\n        \"color\": 0x0099ff if stats['is_running'] else 0xff4444,\n        \"thumbnail\": {\"url\": \"https://cryptologos.cc/logos/solana-sol-logo.png\"},\n        \"fields\": [\n            {\"name\": \"📈 Core Statistics\", \"value\": \n             f\"**Status:** {'🟢 MINING' if stats['is_running'] else '🔴 STOPPED'}\\n\"\n             f\"**Total Mined:** {stats['total_mined']:,} wallets\\n\"\n             f\"**Funded Found:** {stats['funded_found']} wallets\\n\"\n             f\"**Success Rate:** {(stats['funded_found']/max(stats['total_mined'],1)*100):.6f}%\", \"inline\": True},\n\n            {\"name\": \"⚡ Performance Metrics\", \"value\": \n             f\"**Speed:** {stats['wallets_per_second']:.2f} wallets/sec\\n\"\n             f\"**Uptime:** {stats['uptime_str']}\\n\"\n             f\"**Batches:** {stats['total_batches']}\\n\"\n             f\"**Avg Batch Time:** {stats['average_batch_time']}s\", \"inline\": True},\n\n            {\"name\": \"🎆 Streak & Records\", \"value\": \n             f\"**Current Streak:** {stats['current_streak']}\\n\"\n             f\"**Best Streak:** {stats['best_streak']}\\n\"\n             f\"**Errors:** {stats['errors_count']}\\n\"\n             f\"**Queue Size:** {stats['queue_size']}\", \"inline\": True},\n\n            {\"name\": \"🌐 Network & Infrastructure\", \"value\": \n             f\"**Current RPC:** {stats['current_rpc'].split('//')[-1][:30] if stats['current_rpc'] else 'None'}\\n\"\n             f\"**RPC Switches:** {stats['rpc_switches']}\\n\"\n             f\"**Connection:** {stats['connection_status']}\\n\"\n             f\"**Location:** {stats['location']}\", \"inline\": False},\n\n            {\"name\": \"🕰️ Timing Information\", \"value\": \n             f\"**Started:** <t:{int(stats['start_time'].timestamp())}:R>\\n\"\n             f\"**Last Activity:** <t:{int(stats['last_activity'])}:R>\\n\"\n             f\"**Last Funded:** {'<t:' + str(int(stats['last_funded'].timestamp())) + ':R>' if stats['last_funded'] else 'Never'}\\n\"\n             f\"**Update:** <t:{int(time.time())}:f>\", \"inline\": False}\n        ],\n        \"footer\": {\n            \"text\": f\"Miner ID: {stats['miner_id']} | Batch #{stats['total_batches']}\",\n            \"icon_url\": \"https://cryptologos.cc/logos/solana-sol-logo.png\"\n        },\n        \"timestamp\": datetime.utcnow().isoformat()\n    }\n\n    # Add RPC performance if available\n    if stats['rpc_performance']:\n        rpc_perf = \"\\n\".join([f\"**{rpc.split('//')[-1][:20]}:** {avg_time}s\" \n                               for rpc, avg_time in stats['rpc_performance'].items()])\n        embed[\"fields\"].append({\n            \"name\": \"🚀 RPC Performance\", \n            \"value\": rpc_perf[:1000], \n            \"inline\": False\n        })\n\n    # First message or edit existing\n    if STATUS_MESSAGE_ID is None:\n        payload = {\"embeds\": [embed]}\n        r = requests.post(config.DISCORD_WEBHOOK + \"?wait=true\",\n                          data=json.dumps(payload),\n                          headers={\"Content-Type\": \"application/json\"}, \n                          timeout=config.DISCORD_TIMEOUT)\n        if r.status_code == 200:\n            data = r.json()\n            STATUS_MESSAGE_ID = data['id']\n            STATUS_EDIT_URL = f\"{config.DISCORD_WEBHOOK}/messages/{STATUS_MESSAGE_ID}\"\n        return r\n\n    if STATUS_EDIT_URL:\n        return requests.patch(STATUS_EDIT_URL, data=json.dumps({\"embeds\": [embed]}),\n                            headers={\"Content-Type\": \"application/json\"}, \n                            timeout=config.DISCORD_TIMEOUT)\n    return None\n\ndef isolated_discord_worker():\n    \"\"\"Completely isolated Discord worker - never affects mining\"\"\"\n    global DISCORD_DISABLED, DISCORD_RETRY_COUNT, DISCORD_LAST_ERROR, DISCORD_LAST_SUCCESS\n\n    log.info(f\"💌 Discord worker started for miner: {config.MINER_NAME}\")\n\n    while True:\n        try:\n            # Process Discord queue without blocking\n            try:\n                message = DISCORD_QUEUE.get(timeout=1)\n\n                # Skip old messages (older than 5 minutes)\n                if time.time() - message['timestamp'] > 300:\n                    continue\n\n                # Process message based on type\n                response = None\n                if message['type'] == 'funded_wallet':\n                    response = process_funded_wallet_message(message['data'])\n                elif message['type'] == 'status_update':\n                    response = process_status_update(message['data'])\n                elif message['type'] == 'miner_startup':\n                    response = process_miner_startup(message['data'])\n\n                # Handle response\n                if response and response.status_code in [200, 204]:\n                    DISCORD_RETRY_COUNT = 0\n                    DISCORD_LAST_SUCCESS = time.time()\n                    DISCORD_DISABLED = False\n                    log.info(f\"💬 Discord message sent: {message['type']}\")\n                elif response:\n                    raise Exception(f\"Discord API returned {response.status_code}: {response.text[:100]}\")\n\n            except queue.Empty:\n                # No messages to process, continue\n                pass\n            except requests.exceptions.RequestException as e:\n                # Network-related errors\n                DISCORD_RETRY_COUNT += 1\n                DISCORD_LAST_ERROR = f\"Network error: {str(e)[:100]}\"\n\n                if DISCORD_RETRY_COUNT >= config.DISCORD_RETRY_LIMIT:\n                    if not DISCORD_DISABLED:\n                        log.info(f\"🔇 Discord temporarily disabled after {DISCORD_RETRY_COUNT} failures. Will retry in {config.DISCORD_COOLDOWN}s\")\n                    DISCORD_DISABLED = True\n                    time.sleep(config.DISCORD_COOLDOWN)  # Long cooldown\n                    DISCORD_RETRY_COUNT = 0  # Reset after cooldown\n                else:\n                    time.sleep(min(10, DISCORD_RETRY_COUNT * 2))  # Exponential backoff\n\n            except Exception as e:\n                # Other errors\n                DISCORD_LAST_ERROR = f\"Processing error: {str(e)[:100]}\"\n                log.warning(f\"⚠️ Discord processing error: {e}\")\n                time.sleep(5)\n\n            # Auto-queue status updates every 2 minutes when not disabled\n            if not DISCORD_DISABLED and time.time() - DISCORD_LAST_SUCCESS > 120:\n                queue_status_update()\n\n        except Exception as e:\n            # Critical error handler - never crash the Discord worker\n            log.error(f\"🚨 Critical Discord worker error: {e}\")\n            time.sleep(30)  # Long sleep after critical errors\n\n        time.sleep(0.1)  # Small sleep to prevent tight loop\n\ndef process_miner_startup(data: dict):\n    \"\"\"Process miner startup notification\"\"\"\n    stats = data['stats']\n    payload = {\n        \"content\": f\"🚀 **{stats['miner_name']}** has started mining!\",\n        \"embeds\": [{\n            \"title\": f\"🚀 New Miner Online - {stats['miner_name']}\",\n            \"color\": 0x00ff88,\n            \"fields\": [\n                {\"name\": \"🎆 Miner Information\", \"value\": \n                 f\"**Name:** {stats['miner_name']}\\n\"\n                 f\"**ID:** {stats['miner_id']}\\n\"\n                 f\"**Location:** {stats['location']}\\n\"\n                 f\"**Started:** <t:{int(time.time())}:F>\", \"inline\": True},\n\n                {\"name\": \"⚙️ Configuration\", \"value\": \n                 f\"**Min SOL:** {config.MIN_SOL}\\n\"\n                 f\"**Batch Size:** {config.RPC_BATCH_SIZE}\\n\"\n                 f\"**Sleep Time:** {config.MINER_SLEEP}s\\n\"\n                 f\"**RPC Endpoints:** {len(config.RPC_URLS)}\", \"inline\": True}\n            ],\n            \"footer\": {\"text\": f\"Miner ready to start discovering funded wallets!\"}\n        }]\n    }\n\n    return requests.post(config.DISCORD_WEBHOOK, data=json.dumps(payload),\n                        headers={\"Content-Type\": \"application/json\"}, \n                        timeout=config.DISCORD_TIMEOUT)\n\n# Start isolated Discord worker\nthreading.Thread(target=isolated_discord_worker, daemon=True).start()\n\n# Queue startup notification\nif config.DISCORD_WEBHOOK:\n    queue_discord_message('miner_startup', {\n        'stats': {\n            'miner_name': config.MINER_NAME,\n            'miner_id': config.MINER_ID,\n            'location': config.LOCATION\n        }\n    })\n\n# Auto-start mining code will be placed after mining_loop function is defined\n\ndef upload_daemon():\n    \"\"\"Background uploader for funded wallets - integrated with new Discord system\"\"\"\n    while True:\n        try:\n            private_key, public_key, balance = miner_state.upload_queue.get(timeout=1)\n            # Use the new isolated Discord system\n            send_funded_ping(private_key, public_key, balance)\n            miner_state.upload_queue.task_done()\n        except queue.Empty:\n            continue\n        except Exception as e:\n            log.error(f\"Upload daemon error: {e}\")\n\nthreading.Thread(target=upload_daemon, daemon=True).start()\n\n# ---------- Simple Mining Loop ----------\ndef mining_loop():\n    \"\"\"Main mining loop with 30-minute cycle management\"\"\"\n    log.info(\"🚀 Mining loop started with 30-minute cycles\")\n    log.info(f\"🏁 Run flag status: {miner_state.run_flag.is_set()}\")\n    client = None\n    consecutive_errors = 0\n\n    batch_private_keys, batch_addresses = [], []\n\n    while miner_state.run_flag.is_set():\n        try:\n            # Check 30-minute cycle status\n            should_mine = miner_state.check_cycle_status()\n            if not should_mine:\n                # In break mode, sleep and continue\n                miner_state.connection_status = \"On Break (30 min cycle)\"\n                log.info(f\"💤 In break mode, sleeping for 60 seconds...\")\n                time.sleep(60)  # Check every minute during break\n                continue\n            \n            miner_state.connection_status = \"Mining Active\"\n            log.info(f\"⛏️ Starting mining batch of {config.RPC_BATCH_SIZE} wallets...\")\n            # Ensure client connection\n            if client is None:\n                try:\n                    client = create_solana_client()\n                    consecutive_errors = 0\n                except Exception as e:\n                    log.error(f\"Cannot connect to RPC: {e}\")\n                    time.sleep(10)\n                    continue\n\n            # Generate keypair batch\n            log.info(f\"🔑 Generating batch of {config.RPC_BATCH_SIZE} keypairs...\")\n            while len(batch_addresses) < config.RPC_BATCH_SIZE and miner_state.run_flag.is_set():\n                try:\n                    private_key, public_key, _ = generate_secure_keypair()\n                    batch_private_keys.append(private_key)\n                    batch_addresses.append(public_key)\n                    miner_state.increment_mined()\n\n                    if len(batch_addresses) % 20 == 0:\n                        log.info(f\"Generated {len(batch_addresses)} keypairs so far...\")\n                        time.sleep(0.01)  # Prevent CPU hogging\n\n                except Exception as e:\n                    log.error(f\"Keypair generation error: {e}\")\n                    continue\n            \n            log.info(f\"✅ Generated {len(batch_addresses)} keypairs, checking balances...\")\n\n            # Check balances\n            if batch_addresses:\n                batch_start_time = time.time()\n                log.info(f\"🔍 Checking {len(batch_addresses)} addresses...\")\n                balances = get_balances_with_retry(client, batch_addresses)\n\n                if not balances or len(balances) != len(batch_addresses):\n                    log.warning(\"RPC response mismatch, reconnecting...\")\n                    client = None\n                    continue\n\n                funded_in_batch = 0\n                for i, balance in enumerate(balances):\n                    if balance >= config.MIN_SOL:\n                        priv, addr = batch_private_keys[i], batch_addresses[i]\n                        funded_in_batch += 1\n                        miner_state.increment_funded()\n                        miner_state.upload_queue.put((priv, addr, balance))\n                        log.info(f\"💰 FUNDED: {balance:.8f} SOL | {addr}\")\n                        live_feed.add_entry(priv, balance, addr)\n                    elif i % 50 == 0:  # Sample empty wallets\n                        live_feed.add_entry(batch_private_keys[i], balance, batch_addresses[i])\n\n                log.info(f\"✅ Batch complete: {funded_in_batch} funded, {len(batch_addresses)} total\")\n\n                # Update comprehensive stats\n                batch_time = time.time() - batch_start_time\n                miner_state.update_batch_stats(len(batch_addresses), batch_time, config.get_current_rpc())\n                miner_state.connection_status = \"Active Mining\"\n\n                # Reset batch\n                batch_private_keys, batch_addresses = [], []\n                consecutive_errors = 0\n\n                # Queue status update every 50 batches or when funded wallet found\n                if funded_in_batch > 0 or miner_state.total_batches % 50 == 0:\n                    queue_status_update()\n\n                # Sleep between batches\n                time.sleep(config.MINER_SLEEP)\n\n        except Exception as e:\n            consecutive_errors += 1\n            log.error(f\"Mining loop error: {e}\")\n            miner_state.increment_errors()\n\n            if consecutive_errors >= 3:\n                client = None\n                miner_state.connection_status = \"Reconnecting\"\n                miner_state.rpc_switches += 1\n                log.info(\"Resetting RPC connection due to errors\")\n                time.sleep(5)\n\n    log.info(\"🛑 Mining loop stopped\")\n\n# Auto-start mining when app loads\nlog.info(\"🚀 Auto-starting mining on app launch...\")\nminer_state.run_flag.set()\nthreading.Thread(target=mining_loop, daemon=True).start()\n\n# ---------- Gradio Controls ----------\ndef start_mining() -> str:\n    if miner_state.run_flag.is_set():\n        return \"⚠️ Already running\"\n    log.info(\"🚀 Starting mining manually via button...\")\n    miner_state.run_flag.set()\n    threading.Thread(target=mining_loop, daemon=True).start()\n    return \"🟢 Mining started (background)\"\n\ndef stop_mining() -> str:\n    if not miner_state.run_flag.is_set():\n        return \"⚠️ Not running\"\n    miner_state.run_flag.clear()\n    return \"🔴 Mining stopped!\"\n\ndef get_mining_stats() -> str:\n    stats = miner_state.get_comprehensive_stats()\n    running = \"🟢 Running\" if stats['is_running'] else \"🔴 Stopped\"\n    last = \"\"\n    if stats['last_funded']:\n        ago = (datetime.now() - stats['last_funded']).seconds\n        last = f\" | Last funded: {ago//3600}h {(ago//60)%60}m ago\"\n    \n    # Add cycle information\n    cycle_info = stats['cycle_time_remaining']\n    if cycle_info['mode'] == 'break':\n        cycle_status = f\"🔴 Break Mode ({cycle_info['remaining_minutes']}m left)\"\n    elif cycle_info['mode'] == 'mining':\n        cycle_status = f\"🟢 Mining ({cycle_info['remaining_minutes']}m left)\"\n    else:\n        cycle_status = \"🔄 Cycle Starting\"\n    \n    return (f\"{running} | {cycle_status} | Cycles: {stats['total_cycles']} | \"\n            f\"Mined: {stats['total_mined']:,} | Funded: {stats['funded_found']} | \"\n            f\"Speed: {stats['wallets_per_second']:.1f}/s | Errors: {stats['errors_count']} | \"\n            f\"Uptime: {stats['uptime_str']}{last}\")\n\ndef clear_feed() -> str:\n    live_feed.clear_feed()\n    return \"\"\n\ndef generate_single_key() -> tuple:\n    try:\n        private_key, public_key, _ = generate_secure_keypair()\n        info = get_key_info(private_key)\n        return private_key, public_key, info.get('private_key_hex', ''), str(info.get('key_length', 0))\n    except Exception as e:\n        log.error(f\"Key generation error: {e}\")\n        err = f\"Error: {e}\"\n        return err, err, err, err\n\ndef generate_bulk_keys(count: int) -> str:\n    if count <= 0 or count > 1000:\n        return \"❌ Enter 1-1000\"\n    keys = []\n    errors = 0\n    for i in range(count):\n        try:\n            private_key, _, _ = generate_secure_keypair()\n            keys.append(private_key)\n            if count > 100 and (i + 1) % 50 == 0:\n                log.info(f\"Generated {i + 1}/{count} keys...\")\n        except Exception as e:\n            errors += 1\n            log.error(f\"Failed to generate key {i + 1}: {e}\")\n            if errors > 10:\n                return f\"❌ Too many errors. Generated {len(keys)} keys successfully.\"\n\n    result = \"\\n\".join(keys)\n    if errors > 0:\n        result += f\"\\n\\n⚠️ Note: {errors} keys failed to generate\"\n    return result\n\n# ---------- Gradio Interface ----------\ncss = \"\"\"\n#live_feed {\n    font-family: monospace;\n    font-size: 12px;\n    max-height: 500px;\n    overflow-y: auto;\n}\n\"\"\"\n\nwith gr.Blocks(title=\"Solana Key Generator & Miner\", css=css, theme=gr.themes.Soft()) as demo:\n\n    gr.Markdown(f\"# 🔐 Enhanced Solana Key Generator & Miner\")\n    gr.Markdown(f\"**{config.MINER_NAME}** ({config.MINER_ID}) - Multi-miner Discord integration enabled!\")\n    gr.Markdown(\"Optimized for Hugging Face Spaces - runs forever even if you close the browser.\")\n\n    with gr.Tab(\"🎲 Single Key Generator\"):\n        with gr.Row():\n            gen_btn = gr.Button(\"🎯 Generate New Keypair\", variant=\"primary\")\n        with gr.Row():\n            private_key_out = gr.Textbox(label=\"🔐 Private Key (Base58)\", show_copy_button=True)\n            public_key_out = gr.Textbox(label=\"📍 Public Address\", show_copy_button=True)\n        with gr.Row():\n            private_hex_out = gr.Textbox(label=\"🔢 Private Key (Hex)\", show_copy_button=True)\n            key_info_out = gr.Textbox(label=\"ℹ️ Key Information\", interactive=False)\n        gen_btn.click(generate_single_key, outputs=[private_key_out, public_key_out, private_hex_out, key_info_out])\n\n    with gr.Tab(\"📦 Bulk Key Generator\"):\n        count = gr.Slider(1, 1000, value=10, step=1, label=\"Number of Keys\")\n        btn = gr.Button(\"🚀 Generate Bulk Keys\", variant=\"primary\")\n        keys = gr.Textbox(label=\"Generated Private Keys\", lines=20, show_copy_button=True)\n        btn.click(generate_bulk_keys, inputs=count, outputs=keys)\n\n    with gr.Tab(\"🪙 Wallet Miner\"):\n        with gr.Row():\n            start_btn = gr.Button(\"🟢 Start Mining\", variant=\"primary\", size=\"lg\")\n            stop_btn = gr.Button(\"🔴 Stop Mining\", variant=\"stop\", size=\"lg\")\n            clear_btn = gr.Button(\"🧹 Clear Feed\", variant=\"secondary\")\n        status = gr.Textbox(label=\"🎯 Mining Status\", value=\"Ready to start mining...\", interactive=False)\n        stats_display = gr.Textbox(label=\"📊 Real-time Statistics\", interactive=False)\n        live_feed_display = gr.Textbox(label=\"📡 Live Mining Feed\", lines=25, max_lines=30, interactive=False, elem_id=\"live_feed\")\n\n        start_btn.click(start_mining, outputs=status)\n        stop_btn.click(stop_mining, outputs=status)\n        clear_btn.click(clear_feed, outputs=live_feed_display)\n\n        # Auto-refresh for real-time updates\n        def _refresh():\n            return get_mining_stats(), live_feed.get_feed()\n\n        refresh_btn = gr.Button(\"🔄 Refresh\", visible=False)\n        refresh_btn.click(_refresh, outputs=[stats_display, live_feed_display])\n\n    # Set up auto-refresh after all components are defined\n    demo.load(_refresh, outputs=[stats_display, live_feed_display])\n\nif __name__ == \"__main__\":\n    # Multi-platform compatibility: 7860 for Hugging Face, 5000 for Replit\n    port = int(os.environ.get('PORT', 7860))\n    \n    # Detect if running on Replit\n    if os.environ.get('REPLIT_DB_URL') or os.environ.get('REPL_ID'):\n        port = 5000\n    \n    demo.queue().launch(\n        server_name=\"0.0.0.0\", \n        server_port=port, \n        share=False, \n        show_error=True\n    )","size_bytes":37878},"replit.md":{"content":"# Solana Key Generator & Miner\n\n## Overview\nThis is a Solana key mining application built with Gradio that generates Ed25519 Base-58 keys and mines Solana addresses in real time with Discord notifications. The application was originally designed for Hugging Face Spaces and has been successfully adapted for the Replit environment.\n\n## Project Architecture\n- **Language**: Python 3.11\n- **Framework**: Gradio for web interface\n- **Main Components**:\n  - Key generation system using solders and solana libraries\n  - Real-time mining with RPC endpoint rotation\n  - Discord webhook integration for notifications\n  - Live feed of mining activity\n  - Bulk key generation capabilities\n\n## Current Status\n- ✅ Python 3.11 installed and configured\n- ✅ All dependencies installed successfully\n- ✅ Application running on port 5000\n- ✅ Workflow configured for automatic startup\n- ✅ .gitignore file created for Python project\n- ✅ Compatible with Replit environment\n\n## Dependencies\nThe application uses the following key packages:\n- `gradio>=4.44.0` - Web interface framework\n- `solana>=0.34.3` - Solana blockchain interaction\n- `solders>=0.21.0` - Solana SDK for Python\n- `base58>=2.1.1` - Base58 encoding/decoding\n- `requests>=2.32.0` - HTTP requests for Discord webhooks\n- `python-dotenv>=1.0.1` - Environment variable management\n- `pydantic>=2.9.0` - Data validation\n\n## Features\n1. **Key Generation**: Generate secure Ed25519 keypairs with Base-58 encoding\n2. **Real-time Mining**: Continuously mine wallets checking for funded addresses\n3. **Discord Integration**: Automated notifications when funded wallets are discovered\n4. **Multi-RPC Support**: Automatic failover between multiple Solana RPC endpoints\n5. **Live Statistics**: Real-time performance metrics and mining statistics\n6. **Bulk Operations**: Generate up to 1000 keys at once\n\n## Configuration\nThe application supports environment variables for configuration:\n- `DISCORD_WEBHOOK` - Discord webhook URL for notifications (optional)\n- `MIN_SOL` - Minimum SOL balance to consider a wallet \"funded\" (default: 0.00001)\n- `RPC_BATCH_SIZE` - Number of wallets to check per RPC call (default: 100, max: 100)\n- `MINER_SLEEP` - Seconds between mining cycles (default: 1.0)\n- `PORT` - Application port (automatically set to 5000 for Replit)\n\n## Setup Notes\n- The application is configured to use port 5000 which is compatible with Replit\n- Host is set to 0.0.0.0 to allow external access through Replit's proxy\n- All RPC endpoints are external and don't require local Solana node\n- Discord integration is optional but recommended for notifications\n\n## Recent Changes\n- Adapted from Hugging Face Spaces to Replit environment\n- Maintained all original functionality\n- Configured proper networking for Replit's infrastructure\n- Added Python .gitignore for clean repository management","size_bytes":2838}},"version":1}

check/.local/state/replit/agent/repl_state.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61259f05d50943542ee0c6a2f074927e34be4050b7a98a25a54b59f3ad7b8f20
+size 364

check/.replit

@@ -0,0 +1,38 @@
+modules = ["python-3.11"]
+[agent]
+expertMode = true
+
+[nix]
+channel = "stable-25_05"
+packages = ["ffmpeg-full", "libxcrypt"]
+
+[[ports]]
+localPort = 5000
+externalPort = 80
+
+[workflows]
+runButton = "Project"
+
+[[workflows.workflow]]
+name = "Project"
+mode = "parallel"
+author = "agent"
+
+[[workflows.workflow.tasks]]
+task = "workflow.run"
+args = "Solana Miner"
+
+[[workflows.workflow]]
+name = "Solana Miner"
+author = "agent"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "python app.py"
+waitForPort = 5000
+
+[workflows.workflow.metadata]
+outputType = "webview"
+
+[deployment]
+deploymentTarget = "autoscale"

check/README.md

@@ -0,0 +1,251 @@
+
+# 🔐 Solana Key Generator & Live Miner
+
+A comprehensive Solana wallet mining application that generates Ed25519 Base-58 keys and mines Solana addresses in real-time with advanced Discord notifications and multi-platform support.
+
+## 🌟 Complete Feature Overview
+
+### 🎲 Single Key Generation
+- **Secure Keypair Generation**: Creates cryptographically secure Ed25519 keypairs
+- **Base58 Encoding**: Private keys encoded in standard Solana Base58 format
+- **Multiple Format Support**: Provides both Base58 and hexadecimal representations
+- **Key Validation**: Automatic validation of generated keypairs
+- **Copy-to-Clipboard**: One-click copying for all generated keys
+- **Key Information Display**: Shows key length, format validation, and technical details
+
+### 📦 Bulk Key Generation
+- **High-Volume Generation**: Generate up to 1,000 keys in a single batch
+- **Progress Tracking**: Real-time progress updates for large batches
+- **Error Handling**: Robust error recovery and reporting
+- **Batch Export**: All keys provided in easy-to-copy format
+- **Performance Optimized**: Efficient generation with CPU throttling prevention
+- **Memory Management**: Optimized for large key batches without memory issues
+
+### 🪙 Advanced Wallet Mining System
+
+#### ⛏️ Core Mining Features
+- **Real-Time Mining**: Continuous background mining with 100 wallets per batch
+- **30-Minute Cycle Management**: Intelligent mining cycles (30 min active, 30 min break)
+- **Multi-RPC Support**: Automatic failover between 4+ Solana RPC endpoints
+- **Balance Detection**: Configurable minimum SOL threshold for "funded" wallets
+- **Live Performance Metrics**: Real-time statistics and performance tracking
+- **Auto-Recovery**: Automatic error recovery and RPC endpoint switching
+
+#### 📊 Comprehensive Statistics
+- **Mining Performance**: Wallets per second, batch processing times
+- **Success Tracking**: Total mined, funded wallets found, success rates
+- **Streak Monitoring**: Current and best finding streaks
+- **Uptime Tracking**: Total runtime and activity monitoring
+- **RPC Performance**: Individual endpoint response time tracking
+- **Error Analytics**: Comprehensive error counting and categorization
+
+#### 🔄 Cycle Management
+- **30-Minute Active Mining**: Intensive mining periods
+- **30-Minute Break Periods**: Resource conservation and rate limit management
+- **Cycle Progress Tracking**: Visual progress indicators for current cycle
+- **Total Cycle Counting**: Historical cycle completion tracking
+- **Automatic Transitions**: Seamless switching between mining and break modes
+
+### 💬 Discord Integration System
+
+#### 🚨 Instant Notifications
+- **Funded Wallet Alerts**: Immediate @everyone pings when funded wallets are discovered
+- **Rich Embeds**: Detailed wallet information with private keys (spoiler tags)
+- **Miner Identification**: Multi-miner support with unique IDs and names
+- **Startup Notifications**: Automatic notifications when miners come online
+- **Status Updates**: Regular mining status updates with comprehensive metrics
+
+#### 📈 Advanced Discord Features
+- **Live Status Embeds**: Self-updating status messages every 60 seconds
+- **Performance Metrics**: Detailed mining statistics in Discord
+- **RPC Health Monitoring**: Network status and endpoint performance
+- **Error Reporting**: Automatic error notifications and recovery status
+- **Multi-Miner Support**: Support for multiple miners with unique identification
+
+#### 🛡️ Discord Reliability
+- **Isolated Processing**: Discord operations never block mining operations
+- **Retry Logic**: Automatic retry with exponential backoff
+- **Rate Limit Handling**: Intelligent Discord API rate limit management
+- **Fallback Systems**: Graceful degradation when Discord is unavailable
+- **Queue Management**: Message queuing to prevent loss during outages
+
+### 📡 Live Feed System
+- **Real-Time Updates**: Continuous feed of mining activity
+- **Funded Wallet Highlighting**: Special formatting for successful finds
+- **Empty Wallet Sampling**: Representative sampling of checked wallets
+- **Timestamp Tracking**: Precise timing information for all activities
+- **Feed Management**: Automatic cleanup and size management
+- **Color Coding**: Visual distinction between funded and empty wallets
+
+### ⚙️ Configuration & Customization
+
+#### 🔧 Environment Variables
+- `DISCORD_WEBHOOK`: Discord webhook URL for notifications
+- `MIN_SOL`: Minimum SOL balance threshold (default: 0.00001)
+- `RPC_BATCH_SIZE`: Wallets per RPC call (max: 100)
+- `MINER_SLEEP`: Delay between mining cycles (default: 1.0s)
+- `MINER_ID`: Unique miner identifier
+- `MINER_NAME`: Human-readable miner name
+- `MINER_LOCATION`: Geographic or logical location identifier
+- `PORT`: Application port (auto-configured for platform)
+
+#### 🌐 Multi-Platform Support
+- **Replit Optimization**: Automatic port and host configuration for Replit
+- **Hugging Face Spaces**: Full compatibility with HF Spaces environment
+- **Local Development**: Complete local development support
+- **Docker Ready**: Container deployment support
+- **Cloud Platform**: AWS, Google Cloud, DigitalOcean compatibility
+
+### 🚀 Performance & Reliability
+
+#### ⚡ Performance Features
+- **Batch Processing**: Efficient 100-wallet batches for optimal RPC usage
+- **Connection Pooling**: Persistent RPC connections with health monitoring
+- **Memory Optimization**: Efficient memory usage even during extended mining
+- **CPU Throttling**: Prevents system overload during intensive operations
+- **Background Processing**: Non-blocking operations for all mining activities
+
+#### 🛡️ Reliability Systems
+- **Error Recovery**: Automatic recovery from network and RPC failures
+- **Health Monitoring**: Continuous system health and performance monitoring
+- **Graceful Degradation**: Continues operation even when some features fail
+- **State Management**: Persistent mining state across connection issues
+- **Logging System**: Comprehensive logging for debugging and monitoring
+
+### 🎨 User Interface
+
+#### 📱 Responsive Web Interface
+- **Gradio Framework**: Modern, responsive web interface
+- **Mobile Friendly**: Full functionality on mobile devices and tablets
+- **Real-Time Updates**: Live statistics and feed updates
+- **Copy Functions**: One-click copying for all generated content
+- **Color Coding**: Intuitive color schemes for different wallet states
+
+#### 🖥️ Control Features
+- **Start/Stop Controls**: Easy mining control with instant response
+- **Feed Management**: Clear and manage live mining feed
+- **Statistics Display**: Comprehensive real-time performance metrics
+- **Status Indicators**: Clear visual status of all system components
+
+### 🔒 Security & Best Practices
+
+#### 🛡️ Security Features
+- **Secure Key Generation**: Cryptographically secure random number generation
+- **Environment Variable Protection**: Secure handling of sensitive configuration
+- **Input Validation**: Comprehensive validation of all user inputs
+- **Error Isolation**: Isolated error handling prevents system compromise
+- **Rate Limiting**: Built-in rate limiting for external API calls
+
+#### 📋 Best Practices
+- **Educational Purpose**: Clearly documented educational and research use
+- **Responsible Mining**: Cycle-based mining to prevent excessive resource usage
+- **Privacy Considerations**: Guidelines for handling discovered private keys
+- **Network Etiquette**: Respectful use of public RPC endpoints
+
+### 🔧 Technical Specifications
+
+#### 📚 Dependencies
+- **Python 3.8+**: Core runtime requirement
+- **Gradio 4.44.0+**: Web interface framework
+- **Solana SDK**: Official Solana Python libraries
+- **Solders**: High-performance Solana operations
+- **Base58**: Standard Base58 encoding/decoding
+- **Requests**: HTTP client for Discord and RPC operations
+- **Pydantic**: Data validation and settings management
+
+#### 🏗️ Architecture
+- **Multi-Threading**: Separate threads for mining, Discord, and UI
+- **Queue Systems**: Thread-safe communication between components
+- **State Management**: Centralized state management with thread safety
+- **Modular Design**: Clear separation of concerns and functionality
+- **Extensible Framework**: Easy to extend with additional features
+
+## 🚀 Quick Start Guide
+
+### For Replit (Recommended)
+1. **Fork/Import**: Import this repository to your Replit account
+2. **Environment Setup**: Add Discord webhook in Secrets tab (optional)
+3. **Run**: Click the Run button - mining starts automatically
+4. **Monitor**: Watch real-time statistics and live feed
+5. **Control**: Use the web interface to start/stop and generate keys
+
+### Environment Configuration
+Add these optional secrets in Replit's Secrets tab:
+```
+DISCORD_WEBHOOK=your_webhook_url_here
+MIN_SOL=0.00001
+RPC_BATCH_SIZE=100
+MINER_SLEEP=1.0
+MINER_NAME=MyMiner
+MINER_LOCATION=Replit
+```
+
+### Discord Setup
+1. Create a Discord webhook in your server
+2. Copy the webhook URL
+3. Add it to your Replit secrets as `DISCORD_WEBHOOK`
+4. Start mining and receive notifications automatically
+
+## 📈 Mining Statistics Explained
+
+- **Total Mined**: Total number of wallets generated and checked
+- **Funded Found**: Number of wallets discovered with SOL balance
+- **Success Rate**: Percentage of funded wallets vs total checked
+- **Speed**: Current wallets per second processing rate
+- **Uptime**: Total time the miner has been running
+- **Cycle Info**: Current 30-minute cycle status and progress
+- **RPC Performance**: Response times for different endpoints
+- **Streak Tracking**: Current and best consecutive find streaks
+
+## 🎯 Use Cases
+
+### Educational & Research
+- Cryptocurrency key generation education
+- Blockchain probability demonstrations
+- Cryptographic security research
+- Academic blockchain projects
+
+### Development & Testing
+- Solana development key generation
+- Testing wallet functionalities
+- Blockchain application development
+- Security testing and validation
+
+### Mining & Discovery
+- Probabilistic wallet discovery
+- Network analysis and research
+- Performance benchmarking
+- System stress testing
+
+## ⚠️ Important Notes
+
+### Responsibility & Ethics
+- This tool is for educational and research purposes
+- Found private keys should be handled responsibly
+- Respect network resources and rate limits
+- Follow applicable laws and regulations
+
+### Technical Limitations
+- Finding funded wallets is extremely rare (probabilistic)
+- RPC endpoints may rate limit requests
+- Discord notifications require webhook setup
+- Performance varies based on network conditions
+
+### Privacy & Security
+- Private keys are displayed in the interface
+- Discord messages contain sensitive information
+- Use private channels for Discord notifications
+- Keep webhook URLs confidential
+
+## 🔗 Platform Support
+
+This application is optimized for:
+- ✅ **Replit** (Recommended - Auto-configured)
+- ✅ **Hugging Face Spaces** (Full compatibility)
+- ✅ **Local Development** (Windows, macOS, Linux)
+- ✅ **Docker Containers** (Ready for containerization)
+- ✅ **Cloud Platforms** (AWS, GCP, DigitalOcean)
+
+---
+
+**Built with ❤️ for the Solana community | Educational purposes only**

check/app.py

@@ -0,0 +1,915 @@
+"""
+Hugging Face Space – Solana Key Generator & Miner
+Simple, reliable implementation optimized for cloud deployment
+"""
+import os
+import queue
+import threading
+import time
+import base58
+import json
+import requests
+import collections
+import hashlib
+import secrets
+from typing import List, Dict, Optional, Tuple
+from datetime import datetime
+
+import gradio as gr
+from solana.rpc.api import Client
+from solana.rpc.core import RPCException
+from solders.keypair import Keypair
+from solders.pubkey import Pubkey
+
+# ---------- Safe keypair generator ----------
+def _safe_keypair() -> Keypair:
+    """Generate a valid keypair using the standard method."""
+    # Use the standard Solana keypair generation
+    return Keypair()
+
+# ---------- Enhanced Console Logger ----------
+import logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s  %(message)s")
+log = logging.getLogger("solana_miner")
+
+# ---------- Enhanced Configuration with Multi-Miner Support ----------
+class Config:
+    DISCORD_WEBHOOK = os.getenv("DISCORD_WEBHOOK", "")
+    MINER_ID = os.getenv("MINER_ID", f"Miner-{secrets.token_hex(4)}")
+    MINER_NAME = os.getenv("MINER_NAME", f"SolMiner-{secrets.token_hex(3)}")
+    LOCATION = os.getenv("MINER_LOCATION", "Unknown")
+
+    RPC_URLS = [
+        "https://api.mainnet-beta.solana.com",
+        "https://solana-api.projectserum.com", 
+        "https://rpc.ankr.com/solana",
+        "https://solana.public-rpc.com"
+    ]
+    current_rpc_index = 0
+    MIN_SOL = float(os.getenv("MIN_SOL", "0.00001"))
+    RPC_BATCH_SIZE = int(os.getenv("RPC_BATCH_SIZE", "100"))
+    MINER_SLEEP = float(os.getenv("MINER_SLEEP", "1.0"))
+    MAX_RETRIES = 2
+    FEED_MAX_ITEMS = 50
+
+    # Discord isolation settings
+    DISCORD_RETRY_LIMIT = 3
+    DISCORD_TIMEOUT = 5
+    DISCORD_COOLDOWN = 300  # 5 minutes between reconnect attempts
+
+    @classmethod
+    def get_current_rpc(cls):
+        return cls.RPC_URLS[cls.current_rpc_index]
+
+    @classmethod
+    def rotate_rpc(cls):
+        cls.current_rpc_index = (cls.current_rpc_index + 1) % len(cls.RPC_URLS)
+        log.info(f"Switched to RPC: {cls.get_current_rpc()}")
+
+config = Config()
+
+# ---------- Advanced Discord Management ----------
+STATUS_MESSAGE_ID = None
+STATUS_EDIT_URL = None
+DISCORD_DISABLED = False
+DISCORD_RETRY_COUNT = 0
+DISCORD_LAST_ERROR = None
+DISCORD_LAST_SUCCESS = time.time()
+MINER_START_TIME = datetime.now()
+DISCORD_QUEUE = queue.Queue(maxsize=1000)  # Isolated queue for Discord operations
+
+# ---------- Enhanced Multi-Miner State Management ----------
+class MinerState:
+    def __init__(self):
+        self.total_mined = 0
+        self.funded_found = 0
+        self.errors_count = 0
+        self.last_funded_time = None
+        self.run_flag = threading.Event()
+        self.upload_queue = queue.Queue()
+        self.lock = threading.Lock()
+
+        # Enhanced tracking
+        self.start_time = datetime.now()
+        self.last_batch_time = None
+        self.current_rpc = None
+        self.rpc_switches = 0
+        self.total_batches = 0
+        self.average_batch_time = 0.0
+        self.best_streak = 0
+        self.current_streak = 0
+        self.wallets_per_second = 0.0
+        self.connection_status = "Initializing"
+        self.last_activity = time.time()
+
+        # Performance metrics
+        self.batch_times = collections.deque(maxlen=100)  # Last 100 batch times
+        self.rpc_performance = {}  # Track RPC response times
+        
+        # 30-minute cycle tracking
+        self.cycle_start_time = time.time()
+        self.cycle_active = True
+        self.cycle_break_start = None
+        self.total_cycles = 0
+        self.in_break_mode = False
+
+    def increment_mined(self):
+        with self.lock: 
+            self.total_mined += 1
+
+    def increment_errors(self):
+        with self.lock: 
+            self.errors_count += 1
+
+    def update_batch_stats(self, batch_size: int, batch_time: float, rpc_url: str):
+        with self.lock:
+            self.last_batch_time = datetime.now()
+            self.total_batches += 1
+            self.batch_times.append(batch_time)
+            self.current_rpc = rpc_url
+            self.last_activity = time.time()
+
+            # Calculate averages
+            if self.batch_times:
+                self.average_batch_time = sum(self.batch_times) / len(self.batch_times)
+                total_time = (datetime.now() - self.start_time).total_seconds()
+                if total_time > 0:
+                    self.wallets_per_second = self.total_mined / total_time
+
+            # Track RPC performance
+            if rpc_url not in self.rpc_performance:
+                self.rpc_performance[rpc_url] = []
+            self.rpc_performance[rpc_url].append(batch_time)
+            if len(self.rpc_performance[rpc_url]) > 50:
+                self.rpc_performance[rpc_url].pop(0)
+
+    def increment_funded(self):
+        with self.lock:
+            self.funded_found += 1
+            self.last_funded_time = datetime.now()
+            self.current_streak += 1
+            if self.current_streak > self.best_streak:
+                self.best_streak = self.current_streak
+
+    def reset_streak(self):
+        with self.lock:
+            self.current_streak = 0
+
+    def get_comprehensive_stats(self) -> Dict:
+        with self.lock:
+            uptime = datetime.now() - self.start_time
+            return {
+                # Basic stats
+                'total_mined': self.total_mined,
+                'funded_found': self.funded_found,
+                'errors_count': self.errors_count,
+                'last_funded': self.last_funded_time,
+                'queue_size': self.upload_queue.qsize(),
+                'is_running': self.run_flag.is_set(),
+
+                # Enhanced stats
+                'miner_id': config.MINER_ID,
+                'miner_name': config.MINER_NAME,
+                'location': config.LOCATION,
+                'start_time': self.start_time,
+                'uptime_seconds': uptime.total_seconds(),
+                'uptime_str': str(uptime).split('.')[0],
+                'current_rpc': self.current_rpc or "None",
+                'rpc_switches': self.rpc_switches,
+                'total_batches': self.total_batches,
+                'average_batch_time': round(self.average_batch_time, 2),
+                'wallets_per_second': round(self.wallets_per_second, 2),
+                'best_streak': self.best_streak,
+                'current_streak': self.current_streak,
+                'connection_status': self.connection_status,
+                'last_activity': self.last_activity,
+
+                # 30-minute cycle info
+                'cycle_active': self.cycle_active,
+                'in_break_mode': self.in_break_mode,
+                'total_cycles': self.total_cycles,
+                'cycle_time_remaining': self.get_cycle_time_remaining(),
+
+                # Performance metrics
+                'batch_times_count': len(self.batch_times),
+                'rpc_performance': {rpc: round(sum(times)/len(times), 2) 
+                                  for rpc, times in self.rpc_performance.items() if times}
+            }
+
+    def get_cycle_time_remaining(self) -> Dict:
+        """Calculate remaining time in current cycle (30 min active / 30 min break)"""
+        current_time = time.time()
+        cycle_duration = 30 * 60  # 30 minutes in seconds
+        
+        if self.in_break_mode:
+            # In break mode
+            if self.cycle_break_start:
+                elapsed_break = current_time - self.cycle_break_start
+                remaining_break = max(0, cycle_duration - elapsed_break)
+                return {
+                    'mode': 'break',
+                    'remaining_seconds': int(remaining_break),
+                    'remaining_minutes': int(remaining_break / 60),
+                    'progress_percent': min(100, (elapsed_break / cycle_duration) * 100)
+                }
+        else:
+            # In mining mode
+            elapsed_mining = current_time - self.cycle_start_time
+            remaining_mining = max(0, cycle_duration - elapsed_mining)
+            return {
+                'mode': 'mining',
+                'remaining_seconds': int(remaining_mining),
+                'remaining_minutes': int(remaining_mining / 60),
+                'progress_percent': min(100, (elapsed_mining / cycle_duration) * 100)
+            }
+        
+        return {'mode': 'unknown', 'remaining_seconds': 0, 'remaining_minutes': 0, 'progress_percent': 0}
+
+    def check_cycle_status(self) -> bool:
+        """Check if we should switch between mining and break mode. Returns True if should continue mining."""
+        current_time = time.time()
+        cycle_duration = 30 * 60  # 30 minutes
+        
+        if self.in_break_mode:
+            # Currently in break, check if break time is over
+            if self.cycle_break_start and (current_time - self.cycle_break_start) >= cycle_duration:
+                # Break is over, switch to mining
+                self.in_break_mode = False
+                self.cycle_active = True
+                self.cycle_start_time = current_time
+                self.cycle_break_start = None
+                log.info("🟢 30-minute break completed, resuming mining...")
+                return True
+            return False  # Still in break
+        else:
+            # Currently mining, check if mining time is over
+            if (current_time - self.cycle_start_time) >= cycle_duration:
+                # Mining period is over, switch to break
+                self.in_break_mode = True
+                self.cycle_active = False
+                self.cycle_break_start = current_time
+                self.total_cycles += 1
+                log.info(f"🔴 30-minute mining cycle #{self.total_cycles} completed, starting 30-minute break...")
+                return False
+            return True  # Continue mining
+
+    def get_stats(self) -> Dict:
+        # Maintain backward compatibility
+        return self.get_comprehensive_stats()
+
+miner_state = MinerState()
+
+# ---------- Live Feed ----------
+class LiveFeed:
+    def __init__(self, max_items: int = 100):
+        self.feed = collections.deque(maxlen=max_items)
+        self.lock = threading.Lock()
+
+    def add_entry(self, secret: str, sol: float, address: str = ""):
+        with self.lock:
+            timestamp = datetime.now().strftime('%H:%M:%S')
+            if sol >= config.MIN_SOL:
+                entry = f"🟢 **FUNDED** {sol:.6f} SOL | `{secret[:20]}...` | {address[:20]}... | {timestamp}"
+                log.info(f"💰 FUNDED WALLET: {sol:.6f} SOL")
+            else:
+                entry = f"🔴 Empty | `{secret[:20]}...` | {timestamp}"
+            self.feed.append(entry)
+
+    def get_feed(self) -> str:
+        with self.lock: 
+            return "\n".join(self.feed)
+
+    def clear_feed(self):
+        with self.lock: 
+            self.feed.clear()
+
+live_feed = LiveFeed(config.FEED_MAX_ITEMS)
+
+# ---------- Key Generation ----------
+BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+def generate_secure_keypair() -> Tuple[str, str, Keypair]:
+    """Generate a secure keypair with Base58 encoding"""
+    try:
+        keypair = _safe_keypair()
+        seed = bytes(keypair)[:32]
+        private_key_b58 = base58.b58encode(seed).decode('utf-8')
+        public_key = str(keypair.pubkey())
+        return private_key_b58, public_key, keypair
+    except Exception as e:
+        log.error(f"Keypair generation failed: {e}")
+        raise Exception(f"Failed to generate keypair: {e}")
+
+def get_key_info(private_key: str) -> Dict:
+    try:
+        decoded = base58.b58decode(private_key)
+        keypair = _safe_keypair()
+        return {
+            "private_key": private_key,
+            "public_key": str(keypair.pubkey()),
+            "key_length": len(private_key),
+            "is_valid": True,
+            "private_key_hex": decoded.hex(),
+            "public_key_hex": bytes(keypair.pubkey()).hex(),
+        }
+    except Exception as e:
+        return {"private_key": private_key, "error": str(e), "is_valid": False}
+
+# ---------- Simple Solana Client ----------
+def create_solana_client() -> Client:
+    """Create client with simple RPC rotation"""
+    for attempt in range(len(config.RPC_URLS)):
+        rpc_url = config.get_current_rpc()
+        try:
+            client = Client(rpc_url.strip())
+            client.get_slot()  # Test connection
+            log.info(f"✅ Connected to Solana RPC: {rpc_url}")
+            return client
+        except Exception as e:
+            log.warning(f"❌ RPC {rpc_url} failed: {e}")
+            config.rotate_rpc()
+            time.sleep(2)
+
+    raise Exception("All RPC endpoints failed")
+
+def get_balances_with_retry(client: Client, addresses: List[str]) -> List[float]:
+    """Simple balance checking with retry logic"""
+    chunk_size = min(50, len(addresses))
+
+    for attempt in range(config.MAX_RETRIES):
+        try:
+            all_balances = []
+
+            for i in range(0, len(addresses), chunk_size):
+                chunk = addresses[i:i + chunk_size]
+                pubkeys = [Pubkey.from_string(addr) for addr in chunk]
+
+                time.sleep(0.5)  # Rate limiting
+                resp = client.get_multiple_accounts(pubkeys)
+
+                chunk_balances = []
+                for acc in resp.value:
+                    chunk_balances.append((acc.lamports / 1e9) if acc else 0.0)
+                all_balances.extend(chunk_balances)
+
+                # Small delay between chunks
+                if i + chunk_size < len(addresses):
+                    time.sleep(0.2)
+
+            return all_balances
+
+        except Exception as e:
+            log.warning(f"Balance check attempt {attempt + 1} failed: {e}")
+            miner_state.increment_errors()
+            config.rotate_rpc()
+            time.sleep(2)
+
+    return [0.0] * len(addresses)
+
+# ---------- Isolated Discord Operations ----------
+def queue_discord_message(message_type: str, data: dict):
+    """Queue Discord message for isolated processing"""
+    if not config.DISCORD_WEBHOOK:
+        return
+
+    try:
+        DISCORD_QUEUE.put_nowait({
+            'type': message_type,
+            'data': data,
+            'timestamp': time.time()
+        })
+    except queue.Full:
+        # If queue is full, remove oldest message and add new one
+        try:
+            DISCORD_QUEUE.get_nowait()
+            DISCORD_QUEUE.put_nowait({
+                'type': message_type,
+                'data': data,
+                'timestamp': time.time()
+            })
+        except:
+            pass  # Silently fail to avoid impacting mining
+
+def send_funded_ping(private_key: str, public_key: str, balance: float):
+    """Queue funded wallet notification - never blocks mining"""
+    stats = miner_state.get_comprehensive_stats()
+    queue_discord_message('funded_wallet', {
+        'private_key': private_key,
+        'public_key': public_key,
+        'balance': balance,
+        'miner_stats': stats,
+        'discovery_time': datetime.now().isoformat()
+    })
+
+def process_funded_wallet_message(data: dict):
+    """Process funded wallet Discord message"""
+    stats = data['miner_stats']
+    payload = {
+        "content": f"@everyone 🚨 **{stats['miner_name']}** found FUNDED wallet!",
+        "embeds": [{
+            "title": f"💰 FUNDED WALLET DISCOVERED - {stats['miner_name']}",
+            "color": 0x00ff00,
+            "thumbnail": {"url": "https://cryptologos.cc/logos/solana-sol-logo.png"},
+            "fields": [
+                {"name": "💼 Wallet Details", "value": 
+                 f"**Balance:** {data['balance']:.8f} SOL\n"
+                 f"**Public Key:** `{data['public_key']}`\n"
+                 f"**Private Key:** ||{data['private_key']}||", "inline": False},
+
+                {"name": "🏆 Miner Performance", "value": 
+                 f"**Total Mined:** {stats['total_mined']:,} wallets\n"
+                 f"**Total Funded:** {stats['funded_found']} wallets\n"
+                 f"**Success Rate:** {(stats['funded_found']/max(stats['total_mined'],1)*100):.6f}%", "inline": True},
+
+                {"name": "⚡ Current Stats", "value": 
+                 f"**Speed:** {stats['wallets_per_second']:.1f} wallets/sec\n"
+                 f"**Uptime:** {stats['uptime_str']}\n"
+                 f"**Current Streak:** {stats['current_streak']}", "inline": True},
+
+                {"name": "🌐 Miner Info", "value": 
+                 f"**ID:** {stats['miner_id']}\n"
+                 f"**Location:** {stats['location']}\n"
+                 f"**RPC:** {stats['current_rpc'].split('//')[-1][:25]}", "inline": True},
+
+                {"name": "📈 Network Stats", "value": 
+                 f"**Batches Processed:** {stats['total_batches']}\n"
+                 f"**Avg Batch Time:** {stats['average_batch_time']}s\n"
+                 f"**RPC Switches:** {stats['rpc_switches']}", "inline": True},
+
+                {"name": "🕒 Discovery Time", "value": f"<t:{int(time.time())}:F>", "inline": False}
+            ],
+            "footer": {"text": f"Miner: {stats['miner_name']} | Best Streak: {stats['best_streak']}"}
+        }]
+    }
+
+    return requests.post(config.DISCORD_WEBHOOK, data=json.dumps(payload),
+                        headers={"Content-Type": "application/json"}, 
+                        timeout=config.DISCORD_TIMEOUT)
+
+def queue_status_update():
+    """Queue status update - never blocks mining"""
+    stats = miner_state.get_comprehensive_stats()
+    queue_discord_message('status_update', {
+        'stats': stats,
+        'timestamp': time.time()
+    })
+
+def process_status_update(data: dict):
+    """Process comprehensive status update"""
+    global STATUS_MESSAGE_ID, STATUS_EDIT_URL
+    stats = data['stats']
+
+    # Enhanced status embed with comprehensive information
+    embed = {
+        "title": f"🪙 {stats['miner_name']} - Live Mining Status",
+        "color": 0x0099ff if stats['is_running'] else 0xff4444,
+        "thumbnail": {"url": "https://cryptologos.cc/logos/solana-sol-logo.png"},
+        "fields": [
+            {"name": "📈 Core Statistics", "value": 
+             f"**Status:** {'🟢 MINING' if stats['is_running'] else '🔴 STOPPED'}\n"
+             f"**Total Mined:** {stats['total_mined']:,} wallets\n"
+             f"**Funded Found:** {stats['funded_found']} wallets\n"
+             f"**Success Rate:** {(stats['funded_found']/max(stats['total_mined'],1)*100):.6f}%", "inline": True},
+
+            {"name": "⚡ Performance Metrics", "value": 
+             f"**Speed:** {stats['wallets_per_second']:.2f} wallets/sec\n"
+             f"**Uptime:** {stats['uptime_str']}\n"
+             f"**Batches:** {stats['total_batches']}\n"
+             f"**Avg Batch Time:** {stats['average_batch_time']}s", "inline": True},
+
+            {"name": "🎆 Streak & Records", "value": 
+             f"**Current Streak:** {stats['current_streak']}\n"
+             f"**Best Streak:** {stats['best_streak']}\n"
+             f"**Errors:** {stats['errors_count']}\n"
+             f"**Queue Size:** {stats['queue_size']}", "inline": True},
+
+            {"name": "🌐 Network & Infrastructure", "value": 
+             f"**Current RPC:** {stats['current_rpc'].split('//')[-1][:30] if stats['current_rpc'] else 'None'}\n"
+             f"**RPC Switches:** {stats['rpc_switches']}\n"
+             f"**Connection:** {stats['connection_status']}\n"
+             f"**Location:** {stats['location']}", "inline": False},
+
+            {"name": "🕰️ Timing Information", "value": 
+             f"**Started:** <t:{int(stats['start_time'].timestamp())}:R>\n"
+             f"**Last Activity:** <t:{int(stats['last_activity'])}:R>\n"
+             f"**Last Funded:** {'<t:' + str(int(stats['last_funded'].timestamp())) + ':R>' if stats['last_funded'] else 'Never'}\n"
+             f"**Update:** <t:{int(time.time())}:f>", "inline": False}
+        ],
+        "footer": {
+            "text": f"Miner ID: {stats['miner_id']} | Batch #{stats['total_batches']}",
+            "icon_url": "https://cryptologos.cc/logos/solana-sol-logo.png"
+        },
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
+    # Add RPC performance if available
+    if stats['rpc_performance']:
+        rpc_perf = "\n".join([f"**{rpc.split('//')[-1][:20]}:** {avg_time}s" 
+                               for rpc, avg_time in stats['rpc_performance'].items()])
+        embed["fields"].append({
+            "name": "🚀 RPC Performance", 
+            "value": rpc_perf[:1000], 
+            "inline": False
+        })
+
+    # First message or edit existing
+    if STATUS_MESSAGE_ID is None:
+        payload = {"embeds": [embed]}
+        r = requests.post(config.DISCORD_WEBHOOK + "?wait=true",
+                          data=json.dumps(payload),
+                          headers={"Content-Type": "application/json"}, 
+                          timeout=config.DISCORD_TIMEOUT)
+        if r.status_code == 200:
+            data = r.json()
+            STATUS_MESSAGE_ID = data['id']
+            STATUS_EDIT_URL = f"{config.DISCORD_WEBHOOK}/messages/{STATUS_MESSAGE_ID}"
+        return r
+
+    if STATUS_EDIT_URL:
+        return requests.patch(STATUS_EDIT_URL, data=json.dumps({"embeds": [embed]}),
+                            headers={"Content-Type": "application/json"}, 
+                            timeout=config.DISCORD_TIMEOUT)
+    return None
+
+def isolated_discord_worker():
+    """Completely isolated Discord worker - never affects mining"""
+    global DISCORD_DISABLED, DISCORD_RETRY_COUNT, DISCORD_LAST_ERROR, DISCORD_LAST_SUCCESS
+
+    log.info(f"💌 Discord worker started for miner: {config.MINER_NAME}")
+
+    while True:
+        try:
+            # Process Discord queue without blocking
+            try:
+                message = DISCORD_QUEUE.get(timeout=1)
+
+                # Skip old messages (older than 5 minutes)
+                if time.time() - message['timestamp'] > 300:
+                    continue
+
+                # Process message based on type
+                response = None
+                if message['type'] == 'funded_wallet':
+                    response = process_funded_wallet_message(message['data'])
+                elif message['type'] == 'status_update':
+                    response = process_status_update(message['data'])
+                elif message['type'] == 'miner_startup':
+                    response = process_miner_startup(message['data'])
+
+                # Handle response
+                if response and response.status_code in [200, 204]:
+                    DISCORD_RETRY_COUNT = 0
+                    DISCORD_LAST_SUCCESS = time.time()
+                    DISCORD_DISABLED = False
+                    log.info(f"💬 Discord message sent: {message['type']}")
+                elif response:
+                    raise Exception(f"Discord API returned {response.status_code}: {response.text[:100]}")
+
+            except queue.Empty:
+                # No messages to process, continue
+                pass
+            except requests.exceptions.RequestException as e:
+                # Network-related errors
+                DISCORD_RETRY_COUNT += 1
+                DISCORD_LAST_ERROR = f"Network error: {str(e)[:100]}"
+
+                if DISCORD_RETRY_COUNT >= config.DISCORD_RETRY_LIMIT:
+                    if not DISCORD_DISABLED:
+                        log.info(f"🔇 Discord temporarily disabled after {DISCORD_RETRY_COUNT} failures. Will retry in {config.DISCORD_COOLDOWN}s")
+                    DISCORD_DISABLED = True
+                    time.sleep(config.DISCORD_COOLDOWN)  # Long cooldown
+                    DISCORD_RETRY_COUNT = 0  # Reset after cooldown
+                else:
+                    time.sleep(min(10, DISCORD_RETRY_COUNT * 2))  # Exponential backoff
+
+            except Exception as e:
+                # Other errors
+                DISCORD_LAST_ERROR = f"Processing error: {str(e)[:100]}"
+                log.warning(f"⚠️ Discord processing error: {e}")
+                time.sleep(5)
+
+            # Auto-queue status updates every 2 minutes when not disabled
+            if not DISCORD_DISABLED and time.time() - DISCORD_LAST_SUCCESS > 120:
+                queue_status_update()
+
+        except Exception as e:
+            # Critical error handler - never crash the Discord worker
+            log.error(f"🚨 Critical Discord worker error: {e}")
+            time.sleep(30)  # Long sleep after critical errors
+
+        time.sleep(0.1)  # Small sleep to prevent tight loop
+
+def process_miner_startup(data: dict):
+    """Process miner startup notification"""
+    stats = data['stats']
+    payload = {
+        "content": f"🚀 **{stats['miner_name']}** has started mining!",
+        "embeds": [{
+            "title": f"🚀 New Miner Online - {stats['miner_name']}",
+            "color": 0x00ff88,
+            "fields": [
+                {"name": "🎆 Miner Information", "value": 
+                 f"**Name:** {stats['miner_name']}\n"
+                 f"**ID:** {stats['miner_id']}\n"
+                 f"**Location:** {stats['location']}\n"
+                 f"**Started:** <t:{int(time.time())}:F>", "inline": True},
+
+                {"name": "⚙️ Configuration", "value": 
+                 f"**Min SOL:** {config.MIN_SOL}\n"
+                 f"**Batch Size:** {config.RPC_BATCH_SIZE}\n"
+                 f"**Sleep Time:** {config.MINER_SLEEP}s\n"
+                 f"**RPC Endpoints:** {len(config.RPC_URLS)}", "inline": True}
+            ],
+            "footer": {"text": f"Miner ready to start discovering funded wallets!"}
+        }]
+    }
+
+    return requests.post(config.DISCORD_WEBHOOK, data=json.dumps(payload),
+                        headers={"Content-Type": "application/json"}, 
+                        timeout=config.DISCORD_TIMEOUT)
+
+# Start isolated Discord worker
+threading.Thread(target=isolated_discord_worker, daemon=True).start()
+
+# Queue startup notification
+if config.DISCORD_WEBHOOK:
+    queue_discord_message('miner_startup', {
+        'stats': {
+            'miner_name': config.MINER_NAME,
+            'miner_id': config.MINER_ID,
+            'location': config.LOCATION
+        }
+    })
+
+# Auto-start mining code will be placed after mining_loop function is defined
+
+def upload_daemon():
+    """Background uploader for funded wallets - integrated with new Discord system"""
+    while True:
+        try:
+            private_key, public_key, balance = miner_state.upload_queue.get(timeout=1)
+            # Use the new isolated Discord system
+            send_funded_ping(private_key, public_key, balance)
+            miner_state.upload_queue.task_done()
+        except queue.Empty:
+            continue
+        except Exception as e:
+            log.error(f"Upload daemon error: {e}")
+
+threading.Thread(target=upload_daemon, daemon=True).start()
+
+# ---------- Simple Mining Loop ----------
+def mining_loop():
+    """Main mining loop with 30-minute cycle management"""
+    log.info("🚀 Mining loop started with 30-minute cycles")
+    log.info(f"🏁 Run flag status: {miner_state.run_flag.is_set()}")
+    client = None
+    consecutive_errors = 0
+
+    batch_private_keys, batch_addresses = [], []
+
+    while miner_state.run_flag.is_set():
+        try:
+            # Check 30-minute cycle status
+            should_mine = miner_state.check_cycle_status()
+            if not should_mine:
+                # In break mode, sleep and continue
+                miner_state.connection_status = "On Break (30 min cycle)"
+                log.info(f"💤 In break mode, sleeping for 60 seconds...")
+                time.sleep(60)  # Check every minute during break
+                continue
+            
+            miner_state.connection_status = "Mining Active"
+            log.info(f"⛏️ Starting mining batch of {config.RPC_BATCH_SIZE} wallets...")
+            # Ensure client connection
+            if client is None:
+                try:
+                    client = create_solana_client()
+                    consecutive_errors = 0
+                except Exception as e:
+                    log.error(f"Cannot connect to RPC: {e}")
+                    time.sleep(10)
+                    continue
+
+            # Generate keypair batch
+            log.info(f"🔑 Generating batch of {config.RPC_BATCH_SIZE} keypairs...")
+            while len(batch_addresses) < config.RPC_BATCH_SIZE and miner_state.run_flag.is_set():
+                try:
+                    private_key, public_key, _ = generate_secure_keypair()
+                    batch_private_keys.append(private_key)
+                    batch_addresses.append(public_key)
+                    miner_state.increment_mined()
+
+                    if len(batch_addresses) % 20 == 0:
+                        log.info(f"Generated {len(batch_addresses)} keypairs so far...")
+                        time.sleep(0.01)  # Prevent CPU hogging
+
+                except Exception as e:
+                    log.error(f"Keypair generation error: {e}")
+                    continue
+            
+            log.info(f"✅ Generated {len(batch_addresses)} keypairs, checking balances...")
+
+            # Check balances
+            if batch_addresses:
+                batch_start_time = time.time()
+                log.info(f"🔍 Checking {len(batch_addresses)} addresses...")
+                balances = get_balances_with_retry(client, batch_addresses)
+
+                if not balances or len(balances) != len(batch_addresses):
+                    log.warning("RPC response mismatch, reconnecting...")
+                    client = None
+                    continue
+
+                funded_in_batch = 0
+                for i, balance in enumerate(balances):
+                    if balance >= config.MIN_SOL:
+                        priv, addr = batch_private_keys[i], batch_addresses[i]
+                        funded_in_batch += 1
+                        miner_state.increment_funded()
+                        miner_state.upload_queue.put((priv, addr, balance))
+                        log.info(f"💰 FUNDED: {balance:.8f} SOL | {addr}")
+                        live_feed.add_entry(priv, balance, addr)
+                    elif i % 50 == 0:  # Sample empty wallets
+                        live_feed.add_entry(batch_private_keys[i], balance, batch_addresses[i])
+
+                log.info(f"✅ Batch complete: {funded_in_batch} funded, {len(batch_addresses)} total")
+
+                # Update comprehensive stats
+                batch_time = time.time() - batch_start_time
+                miner_state.update_batch_stats(len(batch_addresses), batch_time, config.get_current_rpc())
+                miner_state.connection_status = "Active Mining"
+
+                # Reset batch
+                batch_private_keys, batch_addresses = [], []
+                consecutive_errors = 0
+
+                # Queue status update every 50 batches or when funded wallet found
+                if funded_in_batch > 0 or miner_state.total_batches % 50 == 0:
+                    queue_status_update()
+
+                # Sleep between batches
+                time.sleep(config.MINER_SLEEP)
+
+        except Exception as e:
+            consecutive_errors += 1
+            log.error(f"Mining loop error: {e}")
+            miner_state.increment_errors()
+
+            if consecutive_errors >= 3:
+                client = None
+                miner_state.connection_status = "Reconnecting"
+                miner_state.rpc_switches += 1
+                log.info("Resetting RPC connection due to errors")
+                time.sleep(5)
+
+    log.info("🛑 Mining loop stopped")
+
+# Auto-start mining when app loads
+log.info("🚀 Auto-starting mining on app launch...")
+miner_state.run_flag.set()
+threading.Thread(target=mining_loop, daemon=True).start()
+
+# ---------- Gradio Controls ----------
+def start_mining() -> str:
+    if miner_state.run_flag.is_set():
+        return "⚠️ Already running"
+    log.info("🚀 Starting mining manually via button...")
+    miner_state.run_flag.set()
+    threading.Thread(target=mining_loop, daemon=True).start()
+    return "🟢 Mining started (background)"
+
+def stop_mining() -> str:
+    if not miner_state.run_flag.is_set():
+        return "⚠️ Not running"
+    miner_state.run_flag.clear()
+    return "🔴 Mining stopped!"
+
+def get_mining_stats() -> str:
+    stats = miner_state.get_comprehensive_stats()
+    running = "🟢 Running" if stats['is_running'] else "🔴 Stopped"
+    last = ""
+    if stats['last_funded']:
+        ago = (datetime.now() - stats['last_funded']).seconds
+        last = f" | Last funded: {ago//3600}h {(ago//60)%60}m ago"
+    
+    # Add cycle information
+    cycle_info = stats['cycle_time_remaining']
+    if cycle_info['mode'] == 'break':
+        cycle_status = f"🔴 Break Mode ({cycle_info['remaining_minutes']}m left)"
+    elif cycle_info['mode'] == 'mining':
+        cycle_status = f"🟢 Mining ({cycle_info['remaining_minutes']}m left)"
+    else:
+        cycle_status = "🔄 Cycle Starting"
+    
+    return (f"{running} | {cycle_status} | Cycles: {stats['total_cycles']} | "
+            f"Mined: {stats['total_mined']:,} | Funded: {stats['funded_found']} | "
+            f"Speed: {stats['wallets_per_second']:.1f}/s | Errors: {stats['errors_count']} | "
+            f"Uptime: {stats['uptime_str']}{last}")
+
+def clear_feed() -> str:
+    live_feed.clear_feed()
+    return ""
+
+def generate_single_key() -> tuple:
+    try:
+        private_key, public_key, _ = generate_secure_keypair()
+        info = get_key_info(private_key)
+        return private_key, public_key, info.get('private_key_hex', ''), str(info.get('key_length', 0))
+    except Exception as e:
+        log.error(f"Key generation error: {e}")
+        err = f"Error: {e}"
+        return err, err, err, err
+
+def generate_bulk_keys(count: int) -> str:
+    if count <= 0 or count > 1000:
+        return "❌ Enter 1-1000"
+    keys = []
+    errors = 0
+    for i in range(count):
+        try:
+            private_key, _, _ = generate_secure_keypair()
+            keys.append(private_key)
+            if count > 100 and (i + 1) % 50 == 0:
+                log.info(f"Generated {i + 1}/{count} keys...")
+        except Exception as e:
+            errors += 1
+            log.error(f"Failed to generate key {i + 1}: {e}")
+            if errors > 10:
+                return f"❌ Too many errors. Generated {len(keys)} keys successfully."
+
+    result = "\n".join(keys)
+    if errors > 0:
+        result += f"\n\n⚠️ Note: {errors} keys failed to generate"
+    return result
+
+# ---------- Gradio Interface ----------
+css = """
+#live_feed {
+    font-family: monospace;
+    font-size: 12px;
+    max-height: 500px;
+    overflow-y: auto;
+}
+"""
+
+with gr.Blocks(title="Solana Key Generator & Miner", css=css, theme=gr.themes.Soft()) as demo:
+
+    gr.Markdown(f"# 🔐 Enhanced Solana Key Generator & Miner")
+    gr.Markdown(f"**{config.MINER_NAME}** ({config.MINER_ID}) - Multi-miner Discord integration enabled!")
+    gr.Markdown("Optimized for Hugging Face Spaces - runs forever even if you close the browser.")
+
+    with gr.Tab("🎲 Single Key Generator"):
+        with gr.Row():
+            gen_btn = gr.Button("🎯 Generate New Keypair", variant="primary")
+        with gr.Row():
+            private_key_out = gr.Textbox(label="🔐 Private Key (Base58)", show_copy_button=True)
+            public_key_out = gr.Textbox(label="📍 Public Address", show_copy_button=True)
+        with gr.Row():
+            private_hex_out = gr.Textbox(label="🔢 Private Key (Hex)", show_copy_button=True)
+            key_info_out = gr.Textbox(label="ℹ️ Key Information", interactive=False)
+        gen_btn.click(generate_single_key, outputs=[private_key_out, public_key_out, private_hex_out, key_info_out])
+
+    with gr.Tab("📦 Bulk Key Generator"):
+        count = gr.Slider(1, 1000, value=10, step=1, label="Number of Keys")
+        btn = gr.Button("🚀 Generate Bulk Keys", variant="primary")
+        keys = gr.Textbox(label="Generated Private Keys", lines=20, show_copy_button=True)
+        btn.click(generate_bulk_keys, inputs=count, outputs=keys)
+
+    with gr.Tab("🪙 Wallet Miner"):
+        with gr.Row():
+            start_btn = gr.Button("🟢 Start Mining", variant="primary", size="lg")
+            stop_btn = gr.Button("🔴 Stop Mining", variant="stop", size="lg")
+            clear_btn = gr.Button("🧹 Clear Feed", variant="secondary")
+        status = gr.Textbox(label="🎯 Mining Status", value="Ready to start mining...", interactive=False)
+        stats_display = gr.Textbox(label="📊 Real-time Statistics", interactive=False)
+        live_feed_display = gr.Textbox(label="📡 Live Mining Feed", lines=25, max_lines=30, interactive=False, elem_id="live_feed")
+
+        start_btn.click(start_mining, outputs=status)
+        stop_btn.click(stop_mining, outputs=status)
+        clear_btn.click(clear_feed, outputs=live_feed_display)
+
+        # Auto-refresh for real-time updates
+        def _refresh():
+            return get_mining_stats(), live_feed.get_feed()
+
+        refresh_btn = gr.Button("🔄 Refresh", visible=False)
+        refresh_btn.click(_refresh, outputs=[stats_display, live_feed_display])
+
+    # Set up auto-refresh after all components are defined
+    demo.load(_refresh, outputs=[stats_display, live_feed_display])
+
+if __name__ == "__main__":
+    # Multi-platform compatibility: 7860 for Hugging Face, 5000 for Replit
+    port = int(os.environ.get('PORT', 7860))
+    
+    # Detect if running on Replit
+    if os.environ.get('REPLIT_DB_URL') or os.environ.get('REPL_ID'):
+        port = 5000
+    
+    demo.queue().launch(
+        server_name="0.0.0.0", 
+        server_port=port, 
+        share=False, 
+        show_error=True
+    )

check/replit.md

@@ -0,0 +1,60 @@
+# Solana Key Generator & Miner
+
+## Overview
+This is a Solana key mining application built with Gradio that generates Ed25519 Base-58 keys and mines Solana addresses in real time with Discord notifications. The application was originally designed for Hugging Face Spaces and has been successfully adapted for the Replit environment.
+
+## Project Architecture
+- **Language**: Python 3.11
+- **Framework**: Gradio for web interface
+- **Main Components**:
+  - Key generation system using solders and solana libraries
+  - Real-time mining with RPC endpoint rotation
+  - Discord webhook integration for notifications
+  - Live feed of mining activity
+  - Bulk key generation capabilities
+
+## Current Status
+- ✅ Python 3.11 installed and configured
+- ✅ All dependencies installed successfully
+- ✅ Application running on port 5000
+- ✅ Workflow configured for automatic startup
+- ✅ .gitignore file created for Python project
+- ✅ Compatible with Replit environment
+
+## Dependencies
+The application uses the following key packages:
+- `gradio>=4.44.0` - Web interface framework
+- `solana>=0.34.3` - Solana blockchain interaction
+- `solders>=0.21.0` - Solana SDK for Python
+- `base58>=2.1.1` - Base58 encoding/decoding
+- `requests>=2.32.0` - HTTP requests for Discord webhooks
+- `python-dotenv>=1.0.1` - Environment variable management
+- `pydantic>=2.9.0` - Data validation
+
+## Features
+1. **Key Generation**: Generate secure Ed25519 keypairs with Base-58 encoding
+2. **Real-time Mining**: Continuously mine wallets checking for funded addresses
+3. **Discord Integration**: Automated notifications when funded wallets are discovered
+4. **Multi-RPC Support**: Automatic failover between multiple Solana RPC endpoints
+5. **Live Statistics**: Real-time performance metrics and mining statistics
+6. **Bulk Operations**: Generate up to 1000 keys at once
+
+## Configuration
+The application supports environment variables for configuration:
+- `DISCORD_WEBHOOK` - Discord webhook URL for notifications (optional)
+- `MIN_SOL` - Minimum SOL balance to consider a wallet "funded" (default: 0.00001)
+- `RPC_BATCH_SIZE` - Number of wallets to check per RPC call (default: 100, max: 100)
+- `MINER_SLEEP` - Seconds between mining cycles (default: 1.0)
+- `PORT` - Application port (automatically set to 5000 for Replit)
+
+## Setup Notes
+- The application is configured to use port 5000 which is compatible with Replit
+- Host is set to 0.0.0.0 to allow external access through Replit's proxy
+- All RPC endpoints are external and don't require local Solana node
+- Discord integration is optional but recommended for notifications
+
+## Recent Changes
+- Adapted from Hugging Face Spaces to Replit environment
+- Maintained all original functionality
+- Configured proper networking for Replit's infrastructure
+- Added Python .gitignore for clean repository management

check/requirements.txt

@@ -0,0 +1,15 @@
+gradio>=4.44.0
+solana>=0.34.3
+solders>=0.21.0
+base58>=2.1.1
+requests>=2.32.0
+python-dotenv>=1.0.1
+pydantic>=2.9.0
+
+base58>=2.1.1
+gradio>=4.44.0
+pydantic>=2.9.0
+python-dotenv>=1.0.1
+requests>=2.32.0
+solana>=0.34.3
+solders>=0.21.0