Upload app.py

app.py

@@ -0,0 +1,254 @@
+from flask import Flask, render_template, request, jsonify, send_file, session
+from datetime import datetime, timedelta
+import requests
+import json
+import os
+import time
+import base64
+from Crypto.PublicKey import RSA
+from Crypto.Cipher import PKCS1_OAEP
+import qrcode
+import io
+import base58
+import hashlib
+import secrets
+
+app = Flask(__name__)
+app.secret_key = secrets.token_hex(32)
+
+# Storage files
+WALLET_FILE = 'wallets.json'
+PRIVILEGE_FILE = 'privilege_log.json'
+
+# Initialize storage files
+def init_storage():
+    if not os.path.exists(WALLET_FILE):
+        with open(WALLET_FILE, 'w') as f:
+            json.dump({}, f)
+    
+    if not os.path.exists(PRIVILEGE_FILE):
+        with open(PRIVILEGE_FILE, 'w') as f:
+            json.dump({}, f)
+
+class NanoWallet:
+    """Simple Nano-like wallet implementation"""
+    
+    def __init__(self):
+        self.wallets = self.load_wallets()
+    
+    def load_wallets(self):
+        try:
+            with open(WALLET_FILE, 'r') as f:
+                return json.load(f)
+        except:
+            return {}
+    
+    def save_wallets(self):
+        with open(WALLET_FILE, 'w') as f:
+            json.dump(self.wallets, f)
+    
+    def generate_wallet(self, user_id):
+        """Generate a simple wallet address"""
+        # Generate a unique address
+        timestamp = str(time.time())
+        random_bytes = secrets.token_bytes(16)
+        address_data = f"{user_id}{timestamp}".encode() + random_bytes
+        address = base58.b58encode(hashlib.sha256(address_data).digest()[:20]).decode()
+        
+        # Generate a simple "private key" (for demo purposes)
+        private_key = secrets.token_hex(32)
+        
+        wallet_data = {
+            'address': address,
+            'private_key': private_key,  # In real implementation, encrypt this!
+            'balance': '0.000000',
+            'last_update': time.time()
+        }
+        
+        self.wallets[user_id] = wallet_data
+        self.save_wallets()
+        
+        return wallet_data
+    
+    def get_wallet(self, user_id):
+        if user_id not in self.wallets:
+            return self.generate_wallet(user_id)
+        return self.wallets[user_id]
+    
+    def update_balance(self, user_id):
+        """Simulate balance updates every 15 seconds"""
+        if user_id in self.wallets:
+            # Generate a small random amount
+            import random
+            increase = random.uniform(0.000001, 0.00001)
+            current = float(self.wallets[user_id]['balance'])
+            self.wallets[user_id]['balance'] = f"{current + increase:.6f}"
+            self.wallets[user_id]['last_update'] = time.time()
+            self.save_wallets()
+
+class PrivilegeSystem:
+    def __init__(self):
+        self.privilege_log = self.load_privilege_log()
+    
+    def load_privilege_log(self):
+        try:
+            with open(PRIVILEGE_FILE, 'r') as f:
+                return json.load(f)
+        except:
+            return {}
+    
+    def save_privilege_log(self):
+        with open(PRIVILEGE_FILE, 'w') as f:
+            json.dump(self.privilege_log, f)
+    
+    def can_grab_privilege(self, user_id, privilege_type):
+        """Check if user can grab privilege (4-hour cooldown)"""
+        user_key = f"{user_id}_{privilege_type}"
+        
+        if user_key not in self.privilege_log:
+            return True, 0
+        
+        last_grab = self.privilege_log[user_key]
+        current_time = time.time()
+        cooldown = 4 * 3600  # 4 hours in seconds
+        
+        time_since_last = current_time - last_grab
+        time_remaining = max(0, cooldown - time_since_last)
+        
+        return time_since_last >= cooldown, time_remaining
+    
+    def grab_privilege(self, user_id, privilege_type):
+        """Register privilege grab"""
+        user_key = f"{user_id}_{privilege_type}"
+        self.privilege_log[user_key] = time.time()
+        self.save_privilege_log()
+        
+        # Register with external service
+        try:
+            response = requests.get(
+                'https://1hit.no/priv/default.php',
+                params={
+                    'user': user_id,
+                    'type': privilege_type,
+                    'time': int(time.time())
+                },
+                timeout=5
+            )
+            print(f"Registered with external service: {response.status_code}")
+        except Exception as e:
+            print(f"External registration failed: {e}")
+        
+        return True
+
+# Initialize systems
+init_storage()
+wallet_system = NanoWallet()
+privilege_system = PrivilegeSystem()
+
+@app.route('/')
+def index():
+    # Generate or get user ID from session
+    if 'user_id' not in session:
+        session['user_id'] = secrets.token_hex(8)
+    
+    user_id = session['user_id']
+    wallet = wallet_system.get_wallet(user_id)
+    
+    return render_template('index.html', 
+                         wallet=wallet,
+                         user_id=user_id)
+
+@app.route('/get_wallet')
+def get_wallet():
+    user_id = session.get('user_id', secrets.token_hex(8))
+    wallet = wallet_system.get_wallet(user_id)
+    
+    # Update balance for display
+    wallet_system.update_balance(user_id)
+    
+    return jsonify(wallet)
+
+@app.route('/download_wallet')
+def download_wallet():
+    user_id = session.get('user_id')
+    if not user_id:
+        return "No wallet found", 404
+    
+    wallet = wallet_system.get_wallet(user_id)
+    
+    # Create wallet data file
+    wallet_data = f"""=== WEIRD PRIVILEGE SPACE WALLET ===
+User ID: {user_id}
+Wallet Address: {wallet['address']}
+Private Key: {wallet['private_key']}
+Balance: {wallet['balance']} NANO
+Last Updated: {datetime.fromtimestamp(wallet['last_update']).isoformat()}
+
+=== WARNING ===
+Keep this file secure! This is your digital identity.
+"""
+    
+    # Return as downloadable file
+    return send_file(
+        io.BytesIO(wallet_data.encode()),
+        as_attachment=True,
+        download_name=f'wallet_{user_id}.txt',
+        mimetype='text/plain'
+    )
+
+@app.route('/check_privilege/<privilege_type>')
+def check_privilege(privilege_type):
+    user_id = session.get('user_id')
+    if not user_id:
+        return jsonify({'error': 'No user session'}), 401
+    
+    can_grab, time_remaining = privilege_system.can_grab_privilege(user_id, privilege_type)
+    
+    return jsonify({
+        'can_grab': can_grab,
+        'time_remaining': time_remaining,
+        'cooldown_hours': 4
+    })
+
+@app.route('/grab_privilege/<privilege_type>')
+def grab_privilege(privilege_type):
+    user_id = session.get('user_id')
+    if not user_id:
+        return jsonify({'error': 'No user session'}), 401
+    
+    can_grab, time_remaining = privilege_system.can_grab_privilege(user_id, privilege_type)
+    
+    if not can_grab:
+        return jsonify({
+            'success': False,
+            'error': f'Privilege cooldown active. Wait {time_remaining:.0f} seconds.'
+        })
+    
+    # Grab the privilege
+    privilege_system.grab_privilege(user_id, privilege_type)
+    
+    return jsonify({
+        'success': True,
+        'message': f'Grabbed {privilege_type} privilege!',
+        'simulation': 'You have simulated privilege now.'
+    })
+
+@app.route('/simulate_privilege')
+def simulate_privilege():
+    return jsonify({
+        'message': 'YOU HAVE SIMULATED PRIVILEGE NOW',
+        'timestamp': datetime.now().isoformat()
+    })
+
+@app.route('/qr_code/<address>')
+def generate_qr(address):
+    # Generate QR code for wallet address
+    qr = qrcode.make(address)
+    img_io = io.BytesIO()
+    qr.save(img_io, 'PNG')
+    img_io.seek(0)
+    
+    return send_file(img_io, mimetype='image/png')
+
+if __name__ == '__main__':
+    app.run(debug=True, port=5000)