backend.py

```python
from flask import Flask, jsonify, request
from flask_cors import CORS
import threading
import time
import random
from datetime import datetime
import json

app = Flask(__name__)
CORS(app)

# Mock data storage
class SystemStatus:
    def __init__(self):
        self.total_keys_processed = 2100000000000000  # 2.1P in scientific notation
        self.keys_per_second = 24700000  # 24.7M
        self.uptime_percentage = 98.7
        self.matches_found = 0
        self.progress_percentage = 42.8
        self.worker_count = 24
        self.target_count = 12
        self.batch_size = 512  # KB
        self.candidate_speed = 2400000  # 2.4M keys/sec
        self.start_time = datetime.now()

system_status = SystemStatus()

@app.route('/api/status')
def get_status():
    """Get current system status"""
    uptime = datetime.now() - system_status.start_time
    return jsonify({
        'total_keys_processed': system_status.total_keys_processed,
        'keys_per_second': system_status.keys_per_second,
        'uptime_percentage': system_status.uptime_percentage,
        'matches_found': system_status.matches_found,
        'progress_percentage': system_status.progress_percentage,
        'worker_count': system_status.worker_count,
        'target_count': system_status.target_count,
        'batch_size': system_status.batch_size,
        'candidate_speed': system_status.candidate_speed,
        'uptime_seconds': int(uptime.total_seconds()),
        'timestamp': datetime.now().isoformat()
    })

@app.route('/api/workers')
def get_workers():
    """Get worker status information"""
    workers = []
    for i in range(system_status.worker_count):
        workers.append({
            'id': i,
            'status': 'active' if random.random() > 0.1 else 'idle',
            'keys_processed': random.randint(1000000, 100000000),
            'speed': random.randint(1000000, 3000000),
            'last_update': datetime.now().isoformat(),
            'type': random.choice(['CPU', 'GPU', 'FPGA'])
        })
    return jsonify(workers)

@app.route('/api/targets')
def get_targets():
    """Get target addresses being searched"""
    targets = []
    sample_addresses = [
        '1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa',
        '1BitcoinEaterAddressDontSendf59kuE',
        '1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF',
        '1LuckyR1fFHEsXYyx5QK4UFzv3PEAepPMK',
        '1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd'
    ]
    for i in range(system_status.target_count):
        targets.append({
            'id': i,
            'address': sample_addresses[i % len(sample_addresses)],
            'balance': random.randint(0, 100) * 1000,  # BTC balance in satoshis
            'priority': random.choice(['high', 'medium', 'low']),
            'added_date': datetime.now().isoformat()
        })
    return jsonify(targets)

@app.route('/api/start-scan', methods=['POST'])
def start_scan():
    """Start a new scanning session"""
    data = request.json
    # In a real implementation, this would start the scanning process
    return jsonify({
        'status': 'started',
        'session_id': 'session_' + str(int(time.time())),
        'message': 'Scanning session started successfully'
    })

@app.route('/api/stop-scan', methods=['POST'])
def stop_scan():
    """Stop the current scanning session"""
    return jsonify({
        'status': 'stopped',
        'message': 'Scanning session stopped successfully'
    })

@app.route('/api/add-target', methods=['POST'])
def add_target():
    """Add a new target address"""
    data = request.json
    system_status.target_count += 1
    return jsonify({
        'status': 'added',
        'target_count': system_status.target_count,
        'message': 'Target address added successfully'
    })

def update_stats():
    """Background thread to update system statistics"""
    while True:
        time.sleep(5)
        # Simulate some realistic fluctuations
        system_status.keys_per_second = random.randint(24000000, 26000000)
        system_status.progress_percentage = min(100, system_status.progress_percentage + 0.1)
        system_status.total_keys_processed += system_status.keys_per_second * 5

if __name__ == '__main__':
    # Start background stats update thread
    stats_thread = threading.Thread(target=update_stats, daemon=True)
    stats_thread.start()
    
    app.run(host='0.0.0.0', port=5000, debug=True)
```