Spaces:

Scorpiotur
/

backend

Running

App Files Files Community

Scorpiotur commited on Jun 22, 2025

Commit

b6965ce

verified ·

1 Parent(s): 6288f67

Create a complete Node.js/Express backend for Sentimint crypto trading bot SaaS. Requirements: 1. User authentication (JWT) 2. Stripe integration for payments ($99/$299/$999 tiers) 3. Trading bot integration with queue system 4. Real-time WebSocket for live trades 5. Complete API for frontend Must include: - Database models (User, Subscription, Trade) - API endpoints for auth, trading, dashboard, billing - Stripe webhook handling for subscriptions - WebSocket server for real-time updates - Security middleware - Ready to connect with existing React frontend Skip affiliate system for now - will add later. Make it production-ready with error handling. ({/* Affiliate Program - Coming Soon! */} <Badge>Launching July 2025</Badge>) - Follow Up Deployment

Browse files

Files changed (1) hide show

index.html +1480 -439

index.html CHANGED Viewed

@@ -3,508 +3,1549 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Express Auth API Documentation</title>
     <script src="https://cdn.tailwindcss.com"></script>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
     <style>
-        .method-badge {
-            @apply px-2 py-1 rounded text-xs font-bold;
-        }
-        .method-get { @apply bg-blue-100 text-blue-800; }
-        .method-post { @apply bg-green-100 text-green-800; }
-        .endpoint-card:hover {
-            transform: translateY(-2px);
-            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
-        }
-        .tab-active {
-            @apply border-b-2 border-blue-500 text-blue-600;
-        }
         .code-block {
-            font-family: 'Courier New', monospace;
-            @apply bg-gray-800 text-gray-100 p-4 rounded overflow-x-auto;
         }
-        .test-input {
-            @apply w-full p-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500;
         }
     </style>
 </head>
-<body class="bg-gray-50">
     <div class="container mx-auto px-4 py-8">
         <header class="mb-12 text-center">
-            <h1 class="text-4xl font-bold text-gray-800 mb-2">Express Auth API</h1>
-            <p class="text-xl text-gray-600">Simple authentication system with JWT</p>
             <div class="mt-6 flex justify-center space-x-4">
-                <span class="px-3 py-1 bg-blue-100 text-blue-800 rounded-full text-sm">Express.js</span>
-                <span class="px-3 py-1 bg-green-100 text-green-800 rounded-full text-sm">MongoDB</span>
-                <span class="px-3 py-1 bg-purple-100 text-purple-800 rounded-full text-sm">JWT</span>
-                <span class="px-3 py-1 bg-yellow-100 text-yellow-800 rounded-full text-sm">bcrypt</span>
             </div>
         </header>
-        <div class="grid grid-cols-1 lg:grid-cols-3 gap-8">
-            <!-- Documentation Section -->
-            <div class="lg:col-span-2">
-                <div class="bg-white rounded-lg shadow-md p-6 mb-8">
-                    <h2 class="text-2xl font-semibold text-gray-800 mb-4">Project Structure</h2>
-                    <div class="code-block mb-4">
-                        <pre>project-root/
-├── server.js         # Main server file
-├── routes/
-│   └── auth.js       # Authentication routes
-├── middleware/
-│   └── auth.js       # JWT verification middleware
-└── models/
-    └── User.js       # Mongoose User model</pre>
-                    </div>
-                </div>
-                <div class="bg-white rounded-lg shadow-md p-6 mb-8">
-                    <h2 class="text-2xl font-semibold text-gray-800 mb-4">API Endpoints</h2>
-                    <!-- Register Endpoint -->
-                    <div class="endpoint-card bg-white border border-gray-200 rounded-lg p-4 mb-6 transition-all duration-200">
-                        <div class="flex items-center mb-3">
-                            <span class="method-badge method-post">POST</span>
-                            <span class="ml-2 font-mono text-gray-700">/api/auth/register</span>
-                        </div>
-                        <p class="text-gray-600 mb-3">Register a new user account.</p>
-                        <div class="mb-4">
-                            <h4 class="font-medium text-gray-700 mb-2">Request Body</h4>
-                            <div class="code-block">
-                                <pre>{
-    "name": "John Doe",
-    "email": "john@example.com",
-    "password": "securepassword123"
-}</pre>
-                            </div>
-                        </div>
-                        <div>
-                            <h4 class="font-medium text-gray-700 mb-2">Response (Success)</h4>
-                            <div class="code-block">
-                                <pre>{
-    "message": "User registered successfully",
-    "user": {
-        "_id": "507f1f77bcf86cd799439011",
-        "name": "John Doe",
-        "email": "john@example.com"
     }
-}</pre>
-                            </div>
-                        </div>
-                    </div>
-                    <!-- Login Endpoint -->
-                    <div class="endpoint-card bg-white border border-gray-200 rounded-lg p-4 mb-6 transition-all duration-200">
-                        <div class="flex items-center mb-3">
-                            <span class="method-badge method-post">POST</span>
-                            <span class="ml-2 font-mono text-gray-700">/api/auth/login</span>
-                        </div>
-                        <p class="text-gray-600 mb-3">Authenticate user and return JWT token.</p>
-                        <div class="mb-4">
-                            <h4 class="font-medium text-gray-700 mb-2">Request Body</h4>
-                            <div class="code-block">
-                                <pre>{
-    "email": "john@example.com",
-    "password": "securepassword123"
-}</pre>
-                            </div>
-                        </div>
-                        <div>
-                            <h4 class="font-medium text-gray-700 mb-2">Response (Success)</h4>
-                            <div class="code-block">
-                                <pre>{
-    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
-    "user": {
-        "_id": "507f1f77bcf86cd799439011",
-        "name": "John Doe",
-        "email": "john@example.com"
     }
-}</pre>
-                            </div>
-                        </div>
-                    </div>
-                    <!-- Profile Endpoint -->
-                    <div class="endpoint-card bg-white border border-gray-200 rounded-lg p-4 mb-6 transition-all duration-200">
-                        <div class="flex items-center mb-3">
-                            <span class="method-badge method-get">GET</span>
-                            <span class="ml-2 font-mono text-gray-700">/api/user/profile</span>
-                        </div>
-                        <p class="text-gray-600 mb-3">Get authenticated user's profile (protected route).</p>
-                        <div class="mb-4">
-                            <h4 class="font-medium text-gray-700 mb-2">Headers</h4>
-                            <div class="code-block">
-                                <pre>Authorization: Bearer &lt;JWT_TOKEN&gt;</pre>
-                            </div>
-                        </div>
-                        <div>
-                            <h4 class="font-medium text-gray-700 mb-2">Response (Success)</h4>
-                            <div class="code-block">
-                                <pre>{
-    "_id": "507f1f77bcf86cd799439011",
-    "name": "John Doe",
-    "email": "john@example.com",
-    "createdAt": "2023-07-15T10:00:00.000Z"
-}</pre>
-                            </div>
-                        </div>
-                    </div>
                 </div>
-                <!-- Code Implementation -->
-                <div class="bg-white rounded-lg shadow-md p-6">
-                    <h2 class="text-2xl font-semibold text-gray-800 mb-4">Implementation</h2>
-                    <div class="mb-8">
-                        <h3 class="text-xl font-medium text-gray-700 mb-3">1. Install Dependencies</h3>
-                        <div class="code-block">
-                            <pre>npm install express mongoose jsonwebtoken bcryptjs cors dotenv</pre>
-                        </div>
-                    </div>
-                    <div class="mb-8">
-                        <h3 class="text-xl font-medium text-gray-700 mb-3">2. server.js</h3>
-                        <div class="code-block">
-                            <pre>require('dotenv').config();
 const express = require('express');
-const mongoose = require('mongoose');
 const cors = require('cors');
-const authRoutes = require('./routes/auth');
 const app = express();
-// Middleware
-app.use(cors());
-app.use(express.json());
-// Routes
-app.use('/api/auth', authRoutes);
-// Database connection
-mongoose.connect(process.env.MONGO_URI)
-    .then(() => {
-        app.listen(process.env.PORT, () => {
-            console.log(`Server running on port ${process.env.PORT}`);
-        });
-    })
-    .catch(err => console.log(err));</pre>
-                        </div>
-                    </div>
-                    <div class="mb-8">
-                        <h3 class="text-xl font-medium text-gray-700 mb-3">3. models/User.js</h3>
-                        <div class="code-block">
-                            <pre>const mongoose = require('mongoose');
-const bcrypt = require('bcryptjs');
-const userSchema = new mongoose.Schema({
-    name: { type: String, required: true },
-    email: { type: String, required: true, unique: true },
-    password: { type: String, required: true },
-}, { timestamps: true });
-// Hash password before saving
-userSchema.pre('save', async function(next) {
-    if (!this.isModified('password')) return next();
-    this.password = await bcrypt.hash(this.password, 10);
-    next();
 });
-module.exports = mongoose.model('User', userSchema);</pre>
-                        </div>
-                    </div>
-                    <div class="mb-8">
-                        <h3 class="text-xl font-medium text-gray-700 mb-3">4. routes/auth.js</h3>
-                        <div class="code-block">
-                            <pre>const express = require('express');
-const router = express.Router();
 const jwt = require('jsonwebtoken');
-const bcrypt = require('bcryptjs');
 const User = require('../models/User');
-const auth = require('../middleware/auth');
-// Register
-router.post('/register', async (req, res) => {
-    try {
-        const { name, email, password } = req.body;
-        // Check if user exists
-        let user = await User.findOne({ email });
-        if (user) {
-            return res.status(400).json({ message: 'User already exists' });
-        }
-        // Create new user
-        user = new User({ name, email, password });
-        await user.save();
-        // Return user without password
-        const userResponse = { _id: user._id, name: user.name, email: user.email };
-        res.status(201).json({ message: 'User registered successfully', user: userResponse });
-    } catch (err) {
-        res.status(500).json({ message: 'Server error' });
     }
-});
-// Login
-router.post('/login', async (req, res) => {
-    try {
-        const { email, password } = req.body;
-        // Check if user exists
-        const user = await User.findOne({ email });
-        if (!user) {
-            return res.status(400).json({ message: 'Invalid credentials' });
-        }
-        // Check password
-        const isMatch = await bcrypt.compare(password, user.password);
-        if (!isMatch) {
-            return res.status(400).json({ message: 'Invalid credentials' });
         }
-        // Create JWT token
-        const token = jwt.sign(
-            { userId: user._id },
-            process.env.JWT_SECRET,
-            { expiresIn: '1h' }
-        );
-        // Return token and user data
-        const userResponse = { _id: user._id, name: user.name, email: user.email };
-        res.json({ token, user: userResponse });
-    } catch (err) {
-        res.status(500).json({ message: 'Server error' });
     }
-});
-// Get user profile (protected)
-router.get('/user/profile', auth, async (req, res) => {
-    try {
-        const user = await User.findById(req.userId).select('-password');
-        res.json(user);
-    } catch (err) {
-        res.status(500).json({ message: 'Server error' });
     }
-});
-module.exports = router;</pre>
-                        </div>
-                    </div>
-                    <div class="mb-8">
-                        <h3 class="text-xl font-medium text-gray-700 mb-3">5. middleware/auth.js</h3>
-                        <div class="code-block">
-                            <pre>const jwt = require('jsonwebtoken');
-module.exports = (req, res, next) => {
-    const token = req.header('Authorization')?.replace('Bearer ', '');
-    if (!token) {
-        return res.status(401).json({ message: 'No token, authorization denied' });
     }
-    try {
-        const decoded = jwt.verify(token, process.env.JWT_SECRET);
-        req.userId = decoded.userId;
-        next();
-    } catch (err) {
-        res.status(401).json({ message: 'Token is not valid' });
     }
-};</pre>
-                        </div>
-                    </div>
-                    <div>
-                        <h3 class="text-xl font-medium text-gray-700 mb-3">6. .env Configuration</h3>
-                        <div class="code-block">
-                            <pre>PORT=5000
-MONGO_URI=mongodb://localhost:27017/auth_demo
-JWT_SECRET=your_jwt_secret_key</pre>
-                        </div>
-                    </div>
-                </div>
-            </div>
-            <!-- Testing Section -->
-            <div class="lg:col-span-1">
-                <div class="bg-white rounded-lg shadow-md p-6 sticky top-6">
-                    <h2 class="text-2xl font-semibold text-gray-800 mb-4">API Tester</h2>
-                    <div class="mb-4">
-                        <label class="block text-gray-700 mb-2">Base URL</label>
-                        <input type="text" id="baseUrl" value="http://localhost:5000" class="test-input">
-                    </div>
-                    <div class="flex border-b mb-4">
-                        <button class="tab-btn py-2 px-4 font-medium text-gray-600 tab-active" data-tab="register">Register</button>
-                        <button class="tab-btn py-2 px-4 font-medium text-gray-600" data-tab="login">Login</button>
-                        <button class="tab-btn py-2 px-4 font-medium text-gray-600" data-tab="profile">Profile</button>
-                    </div>
-                    <!-- Register Form -->
-                    <div id="register-tab" class="tab-content">
-                        <div class="mb-4">
-                            <label class="block text-gray-700 mb-2">Name</label>
-                            <input type="text" id="register-name" class="test-input" placeholder="John Doe">
-                        </div>
-                        <div class="mb-4">
-                            <label class="block text-gray-700 mb-2">Email</label>
-                            <input type="email" id="register-email" class="test-input" placeholder="john@example.com">
-                        </div>
-                        <div class="mb-4">
-                            <label class="block text-gray-700 mb-2">Password</label>
-                            <input type="password" id="register-password" class="test-input" placeholder="••••••••">
-                        </div>
-                        <button id="register-btn" class="w-full bg-blue-500 hover:bg-blue-600 text-white py-2 px-4 rounded transition">
-                            Register
-                        </button>
-                    </div>
-                    <!-- Login Form -->
-                    <div id="login-tab" class="tab-content hidden">
-                        <div class="mb-4">
-                            <label class="block text-gray-700 mb-2">Email</label>
-                            <input type="email" id="login-email" class="test-input" placeholder="john@example.com">
-                        </div>
-                        <div class="mb-4">
-                            <label class="block text-gray-700 mb-2">Password</label>
-                            <input type="password" id="login-password" class="test-input" placeholder="••••••••">
-                        </div>
-                        <button id="login-btn" class="w-full bg-green-500 hover:bg-green-600 text-white py-2 px-4 rounded transition">
-                            Login
-                        </button>
-                    </div>
-                    <!-- Profile Form -->
-                    <div id="profile-tab" class="tab-content hidden">
-                        <div class="mb-4">
-                            <label class="block text-gray-700 mb-2">JWT Token</label>
-                            <input type="text" id="profile-token" class="test-input" placeholder="Paste your JWT token here">
-                        </div>
-                        <button id="profile-btn" class="w-full bg-purple-500 hover:bg-purple-600 text-white py-2 px-4 rounded transition">
-                            Get Profile
-                        </button>
-                    </div>
-                    <!-- Response Section -->
-                    <div class="mt-6">
-                        <h3 class="text-lg font-medium text-gray-700 mb-2">Response</h3>
-                        <div id="response" class="code-block min-h-32">
-                            <p class="text-gray-400">Response will appear here...</p>
-                        </div>
-                    </div>
                 </div>
             </div>
-        </div>
-    </div>
-    <script>
-        // Tab switching
-        const tabs = document.querySelectorAll('.tab-btn');
-        tabs.forEach(tab => {
-            tab.addEventListener('click', () => {
-                // Update active tab
-                tabs.forEach(t => t.classList.remove('tab-active'));
-                tab.classList.add('tab-active');
-                // Show corresponding content
-                document.querySelectorAll('.tab-content').forEach(content => {
-                    content.classList.add('hidden');
-                });
-                document.getElementById(`${tab.dataset.tab}-tab`).classList.remove('hidden');
-            });
-        });
-        // API Testing
-        const baseUrl = document.getElementById('baseUrl');
-        const responseDiv = document.getElementById('response');
-        // Register
-        document.getElementById('register-btn').addEventListener('click', async () => {
-            const name = document.getElementById('register-name').value;
-            const email = document.getElementById('register-email').value;
-            const password = document.getElementById('register-password').value;
-            if (!name || !email || !password) {
-                responseDiv.innerHTML = '<p class="text-red-400">Please fill all fields</p>';
-                return;
             }
             try {
-                const res = await fetch(`${baseUrl.value}/api/auth/register`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, email, password })
                 });
-                const data = await res.json();
-                responseDiv.innerHTML = `<pre>${JSON.stringify(data, null, 2)}</pre>`;
             } catch (err) {
-                responseDiv.innerHTML = `<p class="text-red-400">Error: ${err.message}</p>`;
             }
         });
-        // Login
-        document.getElementById('login-btn').addEventListener('click', async () => {
-            const email = document.getElementById('login-email').value;
-            const password = document.getElementById('login-password').value;
-            if (!email || !password) {
-                responseDiv.innerHTML = '<p class="text-red-400">Please fill all fields</p>';
-                return;
             }
-            try {
-                const res = await fetch(`${baseUrl.value}/api/auth/login`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ email, password })
-                });
-                const data = await res.json();
-                responseDiv.innerHTML = `<pre>${JSON.stringify(data, null, 2)}</pre>`;
-                // Store token for profile testing
-                if (data.token) {
-                    document.getElementById('profile-token').value = data.token;
-                }
-            } catch (err) {
-                responseDiv.innerHTML = `<p class="text-red-400">Error: ${err.message}</p>`;
             }
-        });
-        // Profile
-        document.getElementById('profile-btn').addEventListener('click', async () => {
-            const token = document.getElementById('profile-token').value;
-            if (!token) {
-                responseDiv.innerHTML = '<p class="text-red-400">Please provide a token</p>';
-                return;
-            }
-            try {
-                const res = await fetch(`${baseUrl.value}/api/user/profile`, {
-                    method: 'GET',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${token}`
-                    }
                 });
-                const data = await res.json();
-                responseDiv.innerHTML = `<pre>${JSON.stringify(data, null, 2)}</pre>`;
-            } catch (err) {
-                responseDiv.innerHTML = `<p class="text-red-400">Error: ${err.message}</p>`;
             }
         });
-    </script>
 <p style="border-radius: 8px; text-align: center; font-size: 12px; color: #fff; margin-top: 16px;position: fixed; left: 8px; bottom: 8px; z-index: 10; background: rgba(0, 0, 0, 0.8); padding: 4px 8px;">Made with <img src="https://enzostvs-deepsite.hf.space/logo.svg" alt="DeepSite Logo" style="width: 16px; height: 16px; vertical-align: middle;display:inline-block;margin-right:3px;filter:brightness(0) invert(1);"><a href="https://enzostvs-deepsite.hf.space" style="color: #fff;text-decoration: underline;" target="_blank" >DeepSite</a> - 🧬 <a href="https://enzostvs-deepsite.hf.space?remix=Scorpiotur/backend" style="color: #fff;text-decoration: underline;" target="_blank" >Remix</a></p></body>
 </html>

 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sentimint Backend Documentation</title>
     <script src="https://cdn.tailwindcss.com"></script>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
     <style>
         .code-block {
+            background-color: #1e293b;
+            color: #f8fafc;
+            padding: 1rem;
+            border-radius: 0.5rem;
+            overflow-x: auto;
+            font-family: 'Courier New', Courier, monospace;
+            font-size: 0.875rem;
+            line-height: 1.5;
+            margin: 1rem 0;
         }
+        .endpoint {
+            background-color: #0f172a;
+            padding: 0.5rem 1rem;
+            border-radius: 0.5rem;
+            margin: 0.5rem 0;
         }
+        .method-get { color: #4ade80; }
+        .method-post { color: #60a5fa; }
+        .method-put { color: #fbbf24; }
+        .method-delete { color: #f87171; }
     </style>
 </head>
+<body class="bg-slate-900 text-slate-100">
     <div class="container mx-auto px-4 py-8">
         <header class="mb-12 text-center">
+            <h1 class="text-4xl font-bold text-emerald-400 mb-2">Sentimint Backend</h1>
+            <p class="text-xl text-slate-300">Production-ready Node.js/Express backend for crypto trading bot SaaS</p>
             <div class="mt-6 flex justify-center space-x-4">
+                <span class="px-4 py-2 bg-emerald-800 rounded-full text-sm">JWT Authentication</span>
+                <span class="px-4 py-2 bg-blue-800 rounded-full text-sm">LemonSqueezy Payments</span>
+                <span class="px-4 py-2 bg-amber-800 rounded-full text-sm">Trading Queue</span>
+                <span class="px-4 py-2 bg-purple-800 rounded-full text-sm">WebSocket</span>
+                <span class="px-4 py-2 bg-pink-800 rounded-full text-sm">Affiliate System</span>
             </div>
         </header>
+        <section class="mb-12">
+            <h2 class="text-2xl font-semibold text-emerald-400 mb-4">Project Structure</h2>
+            <div class="code-block">
+                <pre>
+sentimint-backend/
+├── config/               # Configuration files
+│   ├── database.js       # Database connection
+│   ├── jwt.js            # JWT configuration
+│   └── websocket.js      # WebSocket configuration
+├── controllers/          # Route controllers
+│   ├── auth.controller.js
+│   ├── bot.controller.js
+│   ├── payment.controller.js
+│   ├── affiliate.controller.js
+│   └── user.controller.js
+├── models/               # Database models
+│   ├── User.js
+│   ├── Subscription.js
+│   ├── Trade.js
+│   ├── Affiliate.js
+│   └── Queue.js
+├── middleware/           # Custom middleware
+│   ├── auth.js
+│   ├── error.js
+│   └── validation.js
+├── routes/               # API routes
+│   ├── auth.routes.js
+│   ├── bot.routes.js
+│   ├── payment.routes.js
+│   ├── affiliate.routes.js
+│   └── user.routes.js
+├── services/             # Business logic
+│   ├── auth.service.js
+│   ├── bot.service.js
+│   ├── payment.service.js
+│   ├── affiliate.service.js
+│   ├── queue.service.js
+│   └── websocket.service.js
+├── utils/                # Utility functions
+│   ├── logger.js
+│   ├── helpers.js
+│   └── validators.js
+├── queues/               # Bull queue processors
+│   └── trading.queue.js
+├── app.js                # Express app setup
+├── server.js             # Server entry point
+└── .env                  # Environment variables</pre>
+            </div>
+        </section>
+        <section class="mb-12">
+            <h2 class="text-2xl font-semibold text-emerald-400 mb-4">Database Models</h2>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">User Model</h3>
+                <div class="code-block">
+                    <pre>
+const mongoose = require('mongoose');
+const bcrypt = require('bcryptjs');
+const UserSchema = new mongoose.Schema({
+    email: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true,
+        lowercase: true
+    },
+    password: {
+        type: String,
+        required: true,
+        minlength: 8
+    },
+    isVerified: {
+        type: Boolean,
+        default: false
+    },
+    role: {
+        type: String,
+        enum: ['user', 'admin'],
+        default: 'user'
+    },
+    tradingEnabled: {
+        type: Boolean,
+        default: false
+    },
+    apiKey: {
+        type: String,
+        default: ''
+    },
+    apiSecret: {
+        type: String,
+        default: ''
+    },
+    affiliateCode: {
+        type: String,
+        unique: true
+    },
+    referredBy: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User'
+    },
+    resetPasswordToken: String,
+    resetPasswordExpire: Date,
+    emailVerificationToken: String,
+    emailVerificationExpire: Date,
+    lastLogin: Date,
+    loginHistory: [{
+        ip: String,
+        device: String,
+        timestamp: Date
+    }]
+}, {
+    timestamps: true
+});
+// Hash password before saving
+UserSchema.pre('save', async function(next) {
+    if (!this.isModified('password')) return next();
+    const salt = await bcrypt.genSalt(10);
+    this.password = await bcrypt.hash(this.password, salt);
+    next();
+});
+// Generate affiliate code if not exists
+UserSchema.pre('save', function(next) {
+    if (!this.affiliateCode) {
+        this.affiliateCode = Math.random().toString(36).substring(2, 8) +
+                            Math.random().toString(36).substring(2, 8);
     }
+    next();
+});
+// Method to compare passwords
+UserSchema.methods.matchPassword = async function(enteredPassword) {
+    return await bcrypt.compare(enteredPassword, this.password);
+};
+module.exports = mongoose.model('User', UserSchema);</pre>
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Subscription Model</h3>
+                <div class="code-block">
+                    <pre>
+const mongoose = require('mongoose');
+const SubscriptionSchema = new mongoose.Schema({
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
+    },
+    lemonSqueezyId: {
+        type: String,
+        required: true
+    },
+    orderId: {
+        type: String,
+        required: true
+    },
+    productId: {
+        type: String,
+        required: true,
+        enum: ['basic', 'pro', 'enterprise'] // Corresponds to $99/$299/$999 tiers
+    },
+    status: {
+        type: String,
+        enum: ['active', 'expired', 'cancelled', 'pending'],
+        default: 'pending'
+    },
+    currentPeriodEnd: Date,
+    renewsAt: Date,
+    trialEndsAt: Date,
+    isUsageBased: {
+        type: Boolean,
+        default: false
+    },
+    subscriptionItemId: String,
+    variantId: String,
+    paymentMethod: String,
+    billingAnchor: Number,
+    urls: {
+        updatePaymentMethod: String,
+        customerPortal: String
+    },
+    cancelReason: String,
+    cancelledAt: Date,
+    metadata: mongoose.Schema.Types.Mixed
+}, {
+    timestamps: true
+});
+module.exports = mongoose.model('Subscription', SubscriptionSchema);</pre>
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Trade Model</h3>
+                <div class="code-block">
+                    <pre>
+const mongoose = require('mongoose');
+const TradeSchema = new mongoose.Schema({
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
+    },
+    botId: {
+        type: String,
+        required: true
+    },
+    exchange: {
+        type: String,
+        required: true,
+        enum: ['binance', 'kucoin', 'coinbase', 'kraken']
+    },
+    pair: {
+        type: String,
+        required: true
+    },
+    direction: {
+        type: String,
+        enum: ['long', 'short'],
+        required: true
+    },
+    entryPrice: {
+        type: Number,
+        required: true
+    },
+    exitPrice: {
+        type: Number
+    },
+    amount: {
+        type: Number,
+        required: true
+    },
+    leverage: {
+        type: Number,
+        default: 1
+    },
+    status: {
+        type: String,
+        enum: ['pending', 'open', 'closed', 'cancelled', 'failed'],
+        default: 'pending'
+    },
+    pnl: {
+        type: Number
+    },
+    pnlPercentage: {
+        type: Number
+    },
+    fees: {
+        type: Number
+    },
+    strategy: {
+        type: String
+    },
+    indicators: mongoose.Schema.Types.Mixed,
+    notes: String,
+    closedAt: Date,
+    metadata: mongoose.Schema.Types.Mixed
+}, {
+    timestamps: true
+});
+module.exports = mongoose.model('Trade', TradeSchema);</pre>
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Affiliate Model</h3>
+                <div class="code-block">
+                    <pre>
+const mongoose = require('mongoose');
+const AffiliateSchema = new mongoose.Schema({
+    affiliate: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
+    },
+    referredUser: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
+    },
+    commissionRate: {
+        type: Number,
+        default: 0.3 // 30% commission
+    },
+    commissionAmount: {
+        type: Number,
+        default: 0
+    },
+    status: {
+        type: String,
+        enum: ['pending', 'eligible', 'paid'],
+        default: 'pending'
+    },
+    paymentId: String,
+    paidAt: Date,
+    subscriptionTier: {
+        type: String,
+        enum: ['basic', 'pro', 'enterprise']
+    },
+    metadata: mongoose.Schema.Types.Mixed
+}, {
+    timestamps: true
+});
+// Index for faster queries
+AffiliateSchema.index({ affiliate: 1, referredUser: 1 }, { unique: true });
+module.exports = mongoose.model('Affiliate', AffiliateSchema);</pre>
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Queue Model</h3>
+                <div class="code-block">
+                    <pre>
+const mongoose = require('mongoose');
+const QueueSchema = new mongoose.Schema({
+    jobId: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    type: {
+        type: String,
+        required: true,
+        enum: ['trade', 'analysis', 'alert']
+    },
+    status: {
+        type: String,
+        enum: ['queued', 'processing', 'completed', 'failed', 'cancelled'],
+        default: 'queued'
+    },
+    priority: {
+        type: Number,
+        default: 0
+    },
+    data: mongoose.Schema.Types.Mixed,
+    result: mongoose.Schema.Types.Mixed,
+    error: mongoose.Schema.Types.Mixed,
+    startedAt: Date,
+    completedAt: Date,
+    attempts: {
+        type: Number,
+        default: 0
+    },
+    maxAttempts: {
+        type: Number,
+        default: 3
+    },
+    delay: {
+        type: Number,
+        default: 0
+    },
+    timeout: {
+        type: Number,
+        default: 30000 // 30 seconds
+    },
+    createdBy: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User'
     }
+}, {
+    timestamps: true
+});
+module.exports = mongoose.model('Queue', QueueSchema);</pre>
+                </div>
+            </div>
+        </section>
+        <section class="mb-12">
+            <h2 class="text-2xl font-semibold text-emerald-400 mb-4">API Endpoints</h2>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Authentication</h3>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/auth/register - Register a new user
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/auth/login - Login user
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/auth/forgot-password - Request password reset
+                </div>
+                <div class="endpoint">
+                    <span class="method-put">PUT</span> /api/v1/auth/reset-password/:token - Reset password
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/auth/verify-email/:token - Verify email
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/auth/resend-verification - Resend verification email
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/auth/me - Get current user
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/auth/refresh-token - Refresh access token
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/auth/logout - Logout user
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">User</h3>
+                <div class="endpoint">
+                    <span class="method-put">PUT</span> /api/v1/users/me - Update user profile
+                </div>
+                <div class="endpoint">
+                    <span class="method-put">PUT</span> /api/v1/users/password - Change password
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/users/api-keys - Set exchange API keys
+                </div>
+                <div class="endpoint">
+                    <span class="method-delete">DELETE</span> /api/v1/users/api-keys - Remove API keys
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/users/activity - Get user activity
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Subscription & Payments</h3>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/subscriptions/plans - Get available subscription plans
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/subscriptions/checkout - Create checkout session
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/subscriptions/me - Get user's subscription
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/subscriptions/cancel - Request cancellation
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/subscriptions/update-payment-method - Update payment method
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/subscriptions/webhook - LemonSqueezy webhook handler
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/subscriptions/invoices - Get subscription invoices
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Trading Bot</h3>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/bot/status - Get bot status
                 </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/bot/start - Start trading bot
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/bot/stop - Stop trading bot
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/bot/strategies - Add/update strategy
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/bot/strategies - Get strategies
+                </div>
+                <div class="endpoint">
+                    <span class="method-delete">DELETE</span> /api/v1/bot/strategies/:id - Delete strategy
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/bot/trade - Execute trade
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/bot/trades - Get trade history
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/bot/performance - Get performance metrics
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/bot/queue - Add to trading queue
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/bot/queue - Get queue status
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Affiliate System</h3>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/affiliates/stats - Get affiliate stats
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/affiliates/referrals - Get referral list
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/affiliates/commissions - Get commission history
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/affiliates/link - Get affiliate link
+                </div>
+                <div class="endpoint">
+                    <span class="method-post">POST</span> /api/v1/affiliates/payout - Request payout
+                </div>
+                <div class="endpoint">
+                    <span class="method-get">GET</span> /api/v1/affiliates/payouts - Get payout history
+                </div>
+            </div>
+        </section>
+        <section class="mb-12">
+            <h2 class="text-2xl font-semibold text-emerald-400 mb-4">Core Implementation</h2>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">app.js - Express Setup</h3>
+                <div class="code-block">
+                    <pre>
 const express = require('express');
 const cors = require('cors');
+const helmet = require('helmet');
+const rateLimit = require('express-rate-limit');
+const mongoSanitize = require('express-mongo-sanitize');
+const xss = require('xss-clean');
+const hpp = require('hpp');
+const cookieParser = require('cookie-parser');
+const compression = require('compression');
+const path = require('path');
+const http = require('http');
+const socketio = require('socket.io');
+const logger = require('./utils/logger');
+const errorHandler = require('./middleware/error');
+const websocket = require('./services/websocket.service');
+// Create express app
 const app = express();
+// Trust proxy
+app.set('trust proxy', true);
+// Enable CORS
+app.use(cors({
+    origin: process.env.FRONTEND_URL,
+    credentials: true
+}));
+// Set security HTTP headers
+app.use(helmet());
+// Rate limiting
+const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 200, // limit each IP to 200 requests per windowMs
+    message: 'Too many requests from this IP, please try again later'
+});
+app.use('/api', limiter);
+// Body parser, reading data from body into req.body
+app.use(express.json({ limit: '10kb' }));
+app.use(express.urlencoded({ extended: true, limit: '10kb' }));
+app.use(cookieParser());
+// Data sanitization against NoSQL query injection
+app.use(mongoSanitize());
+// Data sanitization against XSS
+app.use(xss());
+// Prevent parameter pollution
+app.use(hpp());
+// Compress responses
+app.use(compression());
+// Static files
+app.use(express.static(path.join(__dirname, 'public')));
+// API routes
+app.use('/api/v1/auth', require('./routes/auth.routes'));
+app.use('/api/v1/users', require('./routes/user.routes'));
+app.use('/api/v1/subscriptions', require('./routes/payment.routes'));
+app.use('/api/v1/bot', require('./routes/bot.routes'));
+app.use('/api/v1/affiliates', require('./routes/affiliate.routes'));
+// Health check endpoint
+app.get('/health', (req, res) => res.status(200).send('OK'));
+// Handle 404
+app.all('*', (req, res, next) => {
+    res.status(404).json({
+        status: 'fail',
+        message: `Can't find ${req.originalUrl} on this server!`
+    });
 });
+// Error handling middleware
+app.use(errorHandler);
+// Create HTTP server
+const server = http.createServer(app);
+// Set up Socket.io
+const io = socketio(server, {
+    cors: {
+        origin: process.env.FRONTEND_URL,
+        methods: ['GET', 'POST'],
+        credentials: true
+    }
+});
+// Initialize WebSocket service
+websocket.initialize(io);
+module.exports = server;</pre>
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">server.js - Entry Point</h3>
+                <div class="code-block">
+                    <pre>
+const app = require('./app');
+const mongoose = require('mongoose');
+const config = require('./config/database');
+const logger = require('./utils/logger');
+const queueService = require('./services/queue.service');
+// Handle uncaught exceptions
+process.on('uncaughtException', err => {
+    logger.error('UNCAUGHT EXCEPTION! 💥 Shutting down...');
+    logger.error(err.name, err.message);
+    process.exit(1);
+});
+// Connect to database
+mongoose.connect(config.uri, config.options)
+    .then(() => logger.info('DB connection successful!'))
+    .catch(err => {
+        logger.error('DB connection failed!');
+        logger.error(err);
+        process.exit(1);
+    });
+// Start server
+const port = process.env.PORT || 3000;
+const server = app.listen(port, () => {
+    logger.info(`Server running on port ${port}...`);
+});
+// Initialize queues
+queueService.initialize();
+// Handle unhandled promise rejections
+process.on('unhandledRejection', err => {
+    logger.error('UNHANDLED REJECTION! 💥 Shutting down...');
+    logger.error(err.name, err.message);
+    server.close(() => {
+        process.exit(1);
+    });
+});
+// Handle SIGTERM
+process.on('SIGTERM', () => {
+    logger.info('👋 SIGTERM RECEIVED. Shutting down gracefully');
+    server.close(() => {
+        logger.info('💥 Process terminated!');
+    });
+});</pre>
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">WebSocket Service</h3>
+                <div class="code-block">
+                    <pre>
+const logger = require('../utils/logger');
 const jwt = require('jsonwebtoken');
 const User = require('../models/User');
+class WebSocketService {
+    constructor() {
+        this.io = null;
+        this.connectedUsers = new Map();
     }
+    initialize(io) {
+        this.io = io;
+        // Authentication middleware
+        io.use(async (socket, next) => {
+            try {
+                const token = socket.handshake.auth.token;
+                if (!token) {
+                    return next(new Error('Authentication error: Token not provided'));
+                }
+                const decoded = jwt.verify(token, process.env.JWT_SECRET);
+                const user = await User.findById(decoded.id);
+                if (!user) {
+                    return next(new Error('Authentication error: User not found'));
+                }
+                socket.user = user;
+                next();
+            } catch (err) {
+                next(new Error('Authentication error: Invalid token'));
+            }
+        });
+        // Connection handler
+        io.on('connection', (socket) => {
+            logger.info(`New WebSocket connection: ${socket.id}`);
+            // Store user connection
+            if (socket.user) {
+                this.connectedUsers.set(socket.user._id.toString(), socket);
+                logger.info(`User ${socket.user.email} connected via WebSocket`);
+            }
+            // Trade updates subscription
+            socket.on('subscribe:trades', (data) => {
+                if (socket.user) {
+                    socket.join(`user:${socket.user._id}:trades`);
+                    logger.info(`User ${socket.user.email} subscribed to trade updates`);
+                }
+            });
+            // Bot status subscription
+            socket.on('subscribe:bot-status', (data) => {
+                if (socket.user) {
+                    socket.join(`user:${socket.user._id}:bot-status`);
+                    logger.info(`User ${socket.user.email} subscribed to bot status updates`);
+                }
+            });
+            // Queue updates subscription
+            socket.on('subscribe:queue', (data) => {
+                if (socket.user) {
+                    socket.join(`user:${socket.user._id}:queue`);
+                    logger.info(`User ${socket.user.email} subscribed to queue updates`);
+                }
+            });
+            // Disconnection handler
+            socket.on('disconnect', () => {
+                logger.info(`WebSocket disconnected: ${socket.id}`);
+                if (socket.user) {
+                    this.connectedUsers.delete(socket.user._id.toString());
+                }
+            });
+        });
+    }
+    // Send trade update to specific user
+    sendTradeUpdate(userId, trade) {
+        if (this.io) {
+            this.io.to(`user:${userId}:trades`).emit('trade:update', trade);
         }
     }
+    // Send bot status update to specific user
+    sendBotStatusUpdate(userId, status) {
+        if (this.io) {
+            this.io.to(`user:${userId}:bot-status`).emit('bot:status', status);
+        }
     }
+    // Send queue update to specific user
+    sendQueueUpdate(userId, queueItem) {
+        if (this.io) {
+            this.io.to(`user:${userId}:queue`).emit('queue:update', queueItem);
+        }
     }
+    // Send notification to specific user
+    sendNotification(userId, notification) {
+        if (this.io) {
+            const socket = this.connectedUsers.get(userId.toString());
+            if (socket) {
+                socket.emit('notification', notification);
+            }
+        }
     }
+}
+module.exports = new WebSocketService();</pre>
                 </div>
             </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Trading Queue Service</h3>
+                <div class="code-block">
+                    <pre>
+const Queue = require('bull');
+const mongoose = require('mongoose');
+const logger = require('../utils/logger');
+const Trade = require('../models/Trade');
+const QueueModel = require('../models/Queue');
+const websocket = require('./websocket.service');
+const { executeTrade } = require('./bot.service');
+class QueueService {
+    constructor() {
+        this.tradingQueue = null;
+    }
+    initialize() {
+        // Create trading queue
+        this.tradingQueue = new Queue('trading', {
+            redis: {
+                host: process.env.REDIS_HOST,
+                port: process.env.REDIS_PORT,
+                password: process.env.REDIS_PASSWORD
+            },
+            defaultJobOptions: {
+                removeOnComplete: true,
+                removeOnFail: true,
+                attempts: 3,
+                backoff: {
+                    type: 'exponential',
+                    delay: 5000
+                }
             }
+        });
+        // Process queue jobs
+        this.tradingQueue.process('execute-trade', async (job) => {
+            const { userId, tradeData } = job.data;
             try {
+                // Update queue status in DB
+                await QueueModel.findOneAndUpdate(
+                    { jobId: job.id.toString() },
+                    { status: 'processing', startedAt: new Date() },
+                    { new: true }
+                );
+                // Execute the trade
+                const trade = await executeTrade(userId, tradeData);
+                // Update queue status
+                await QueueModel.findOneAndUpdate(
+                    { jobId: job.id.toString() },
+                    { status: 'completed', completedAt: new Date(), result: trade },
+                    { new: true }
+                );
+                // Send WebSocket update
+                websocket.sendQueueUpdate(userId, {
+                    jobId: job.id.toString(),
+                    status: 'completed',
+                    trade
                 });
+                return trade;
             } catch (err) {
+                // Update queue status
+                await QueueModel.findOneAndUpdate(
+                    { jobId: job.id.toString() },
+                    {
+                        status: 'failed',
+                        completedAt: new Date(),
+                        error: err.message,
+                        attempts: job.attemptsMade
+                    },
+                    { new: true }
+                );
+                // Send WebSocket update
+                websocket.sendQueueUpdate(userId, {
+                    jobId: job.id.toString(),
+                    status: 'failed',
+                    error: err.message
+                });
+                throw err;
             }
         });
+        // Event listeners
+        this.tradingQueue.on('completed', (job, result) => {
+            logger.info(`Job ${job.id} completed with result:`, result);
+        });
+        this.tradingQueue.on('failed', (job, err) => {
+            logger.error(`Job ${job.id} failed with error:`, err);
+        });
+        this.tradingQueue.on('error', (err) => {
+            logger.error('Queue error:', err);
+        });
+    }
+    async addTradeToQueue(userId, tradeData) {
+        try {
+            // Add job to queue
+            const job = await this.tradingQueue.add('execute-trade', { userId, tradeData }, {
+                priority: tradeData.priority || 0,
+                delay: tradeData.delay || 0
+            });
+            // Save to database
+            const queueItem = new QueueModel({
+                jobId: job.id.toString(),
+                type: 'trade',
+                status: 'queued',
+                priority: tradeData.priority || 0,
+                data: tradeData,
+                createdBy: userId
+            });
+            await queueItem.save();
+            // Send WebSocket update
+            websocket.sendQueueUpdate(userId, {
+                jobId: job.id.toString(),
+                status: 'queued',
+                position: await job.getState()
+            });
+            return queueItem;
+        } catch (err) {
+            logger.error('Error adding to queue:', err);
+            throw err;
+        }
+    }
+    async getQueueStatus(userId) {
+        try {
+            const jobs = await this.tradingQueue.getJobs(['waiting', 'active', 'completed', 'failed']);
+            // Filter jobs for this user
+            const userJobs = jobs.filter(job => job.data.userId.toString() === userId.toString());
+            // Get from database for more details
+            const queueItems = await QueueModel.find({
+                createdBy: userId,
+                status: { $in: ['queued', 'processing'] }
+            }).sort('-createdAt');
+            return {
+                waiting: await this.tradingQueue.getWaitingCount(),
+                active: await this.tradingQueue.getActiveCount(),
+                completed: await this.tradingQueue.getCompletedCount(),
+                failed: await this.tradingQueue.getFailedCount(),
+                userJobs: queueItems
+            };
+        } catch (err) {
+            logger.error('Error getting queue status:', err);
+            throw err;
+        }
+    }
+}
+module.exports = new QueueService();</pre>
+                </div>
+            </div>
+            <div class="mb-8">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">LemonSqueezy Payment Service</h3>
+                <div class="code-block">
+                    <pre>
+const axios = require('axios');
+const crypto = require('crypto');
+const logger = require('../utils/logger');
+const Subscription = require('../models/Subscription');
+const User = require('../models/User');
+const Affiliate = require('../models/Affiliate');
+const websocket = require('./websocket.service');
+class PaymentService {
+    constructor() {
+        this.apiUrl = 'https://api.lemonsqueezy.com/v1';
+        this.headers = {
+            'Accept': 'application/vnd.api+json',
+            'Content-Type': 'application/vnd.api+json',
+            'Authorization': `Bearer ${process.env.LEMON_SQUEEZY_API_KEY}`
+        };
+    }
+    async createCheckout(user, variantId, affiliateCode = null) {
+        try {
+            // Create checkout URL
+            const response = await axios.post(`${this.apiUrl}/checkouts`, {
+                data: {
+                    type: 'checkouts',
+                    attributes: {
+                        checkout_data: {
+                            email: user.email,
+                            custom: {
+                                user_id: user._id.toString(),
+                                affiliate_code: affiliateCode
+                            }
+                        },
+                        product_options: {
+                            enabled_variants: [variantId],
+                            redirect_url: `${process.env.FRONTEND_URL}/dashboard`,
+                            receipt_button_text: 'Go to Dashboard',
+                            receipt_thank_you_note: 'Thank you for subscribing to Sentimint!'
+                        },
+                        expires_at: null,
+                        test_mode: process.env.NODE_ENV !== 'production'
+                    },
+                    relationships: {
+                        store: {
+                            data: {
+                                type: 'stores',
+                                id: process.env.LEMON_SQUEEZY_STORE_ID
+                            }
+                        },
+                        variant: {
+                            data: {
+                                type: 'variants',
+                                id: variantId
+                            }
+                        }
+                    }
+                }
+            }, { headers: this.headers });
+            return response.data.data.attributes.url;
+        } catch (err) {
+            logger.error('Error creating checkout:', err.response?.data || err.message);
+            throw err;
+        }
+    }
+    async handleWebhook(payload, signature) {
+        try {
+            // Verify webhook signature
+            const hmac = crypto.createHmac('sha256', process.env.LEMON_SQUEEZY_WEBHOOK_SECRET);
+            const digest = hmac.update(JSON.stringify(payload)).digest('hex');
+            if (signature !== digest) {
+                throw new Error('Invalid webhook signature');
             }
+            const eventName = payload.meta.event_name;
+            const eventData = payload.data;
+            logger.info(`Processing LemonSqueezy webhook: ${eventName}`);
+            // Handle different event types
+            switch (eventName) {
+                case 'order_created':
+                    await this.handleOrderCreated(eventData);
+                    break;
+                case 'subscription_created':
+                    await this.handleSubscriptionCreated(eventData);
+                    break;
+                case 'subscription_updated':
+                    await this.handleSubscriptionUpdated(eventData);
+                    break;
+                case 'subscription_cancelled':
+                    await this.handleSubscriptionCancelled(eventData);
+                    break;
+                case 'subscription_expired':
+                    await this.handleSubscriptionExpired(eventData);
+                    break;
+                case 'subscription_resumed':
+                    await this.handleSubscriptionResumed(eventData);
+                    break;
+                case 'subscription_payment_success':
+                    await this.handlePaymentSuccess(eventData);
+                    break;
+                case 'subscription_payment_failed':
+                    await this.handlePaymentFailed(eventData);
+                    break;
+                case 'subscription_payment_recovered':
+                    await this.handlePaymentRecovered(eventData);
+                    break;
+                default:
+                    logger.info(`Unhandled webhook event: ${eventName}`);
             }
+            return { success: true };
+        } catch (err) {
+            logger.error('Error processing webhook:', err);
+            throw err;
+        }
+    }
+    async handleOrderCreated(data) {
+        const customData = data.attributes.custom_data || {};
+        const userId = customData.user_id;
+        const affiliateCode = customData.affiliate_code;
+        if (!userId) return;
+        // Check if this is a subscription purchase
+        const includedSubscriptions = payload.included?.filter(item => item.type === 'subscriptions');
+        if (!includedSubscriptions || includedSubscriptions.length === 0) return;
+        // Handle affiliate commission if applicable
+        if (affiliateCode) {
+            const affiliateUser = await User.findOne({ affiliateCode });
+            if (affiliateUser) {
+                const tier = this.getTierFromVariantId(data.attributes.variant_id);
+                const affiliateRecord = new Affiliate({
+                    affiliate: affiliateUser._id,
+                    referredUser: userId,
+                    subscriptionTier: tier,
+                    status: 'pending'
                 });
+                await affiliateRecord.save();
+                // Notify affiliate
+                websocket.sendNotification(affiliateUser._id, {
+                    type: 'affiliate',
+                    message: `New referral: ${data.attributes.user_email}`
+                });
             }
+        }
+    }
+    async handleSubscriptionCreated(data) {
+        const userId = data.attributes.user_id;
+        if (!userId) return;
+        const user = await User.findById(userId);
+        if (!user) return;
+        const variantId = data.attributes.variant_id;
+        const tier = this.getTierFromVariantId(variantId);
+        // Create or update subscription
+        const subscription = await Subscription.findOneAndUpdate(
+            { user: userId },
+            {
+                lemonSqueezyId: data.id,
+                orderId: data.attributes.order_id,
+                productId: tier,
+                status: 'active',
+                currentPeriodEnd: new Date(data.attributes.renews_at),
+                renewsAt: new Date(data.attributes.renews_at),
+                urls: {
+                    updatePaymentMethod: data.attributes.urls.update_payment_method,
+                    customerPortal: data.attributes.urls.customer_portal
+                },
+                paymentMethod: data.attributes.payment_method,
+                billingAnchor: data.attributes.billing_anchor
+            },
+            { upsert: true, new: true }
+        );
+        // Enable trading for user
+        user.tradingEnabled = true;
+        await user.save();
+        // Send notification
+        websocket.sendNotification(userId, {
+            type: 'subscription',
+            message: `Your ${tier} subscription is now active!`
+        });
+        return subscription;
+    }
+    async handleSubscriptionUpdated(data) {
+        const subscription = await Subscription.findOne({ lemonSqueezyId: data.id });
+        if (!subscription) return;
+        // Update subscription details
+        subscription.currentPeriodEnd = new Date(data.attributes.renews_at);
+        subscription.renewsAt = new Date(data.attributes.renews_at);
+        subscription.paymentMethod = data.attributes.payment_method;
+        subscription.urls.updatePaymentMethod = data.attributes.urls.update_payment_method;
+        subscription.urls.customerPortal = data.attributes.urls.customer_portal;
+        await subscription.save();
+        // Send notification
+        websocket.sendNotification(subscription.user, {
+            type: 'subscription',
+            message: 'Your subscription has been updated'
+        });
+    }
+    async handleSubscriptionCancelled(data) {
+        const subscription = await Subscription.findOne({ lemonSqueezyId: data.id });
+        if (!subscription) return;
+        // Update subscription status
+        subscription.status = 'cancelled';
+        subscription.cancelReason = data.attributes.cancellation_reason;
+        subscription.cancelledAt = new Date(data.attributes.ends_at);
+        await subscription.save();
+        // Disable trading for user
+        const user = await User.findById(subscription.user);
+        if (user) {
+            user.tradingEnabled = false;
+            await user.save();
+        }
+        // Send notification
+        websocket.sendNotification(subscription.user, {
+            type: 'subscription',
+            message: 'Your subscription has been cancelled'
+        });
+    }
+    async handlePaymentSuccess(data) {
+        const subscription = await Subscription.findOne({ lemonSqueezyId: data.attributes.subscription_id });
+        if (!subscription) return;
+        // Update subscription renewal date
+        subscription.currentPeriodEnd = new Date(data.attributes.renews_at);
+        subscription.renewsAt = new Date(data.attributes.renews_at);
+        await subscription.save();
+        // Handle affiliate commission
+        const affiliateRecord = await Affiliate.findOne({
+            referredUser: subscription.user,
+            status: 'pending'
+        });
+        if (affiliateRecord) {
+            const tier = subscription.productId;
+            let commissionAmount = 0;
+            // Calculate commission based on tier
+            if (tier === 'basic') commissionAmount = 99 * 0.3; // 30% of $99
+            if (tier === 'pro') commissionAmount = 299 * 0.3; // 30% of $299
+            if (tier === 'enterprise') commissionAmount = 999 * 0.3; // 30% of $999
+            affiliateRecord.commissionAmount = commissionAmount;
+            affiliateRecord.status = 'eligible';
+            await affiliateRecord.save();
+            // Notify affiliate
+            websocket.sendNotification(affiliateRecord.affiliate, {
+                type: 'affiliate',
+                message: `You've earned $${commissionAmount.toFixed(2)} from a referral!`
+            });
+        }
+        // Send notification to user
+        websocket.sendNotification(subscription.user, {
+            type: 'payment',
+            message: 'Your subscription payment was successful'
         });
+    }
+    getTierFromVariantId(variantId) {
+        // Map LemonSqueezy variant IDs to subscription tiers
+        const variantMap = {
+            [process.env.LEMON_SQUEEZY_BASIC_VARIANT_ID]: 'basic',
+            [process.env.LEMON_SQUEEZY_PRO_VARIANT_ID]: 'pro',
+            [process.env.LEMON_SQUEEZY_ENTERPRISE_VARIANT_ID]: 'enterprise'
+        };
+        return variantMap[variantId] || 'basic';
+    }
+}
+module.exports = new PaymentService();</pre>
+                </div>
+            </div>
+        </section>
+        <section class="mb-12">
+            <h2 class="text-2xl font-semibold text-emerald-400 mb-4">Environment Variables</h2>
+            <div class="code-block">
+                <pre>
+# Server
+NODE_ENV=development
+PORT=3000
+FRONTEND_URL=http://localhost:3000
+# Database
+MONGODB_URI=mongodb://localhost:27017/sentimint
+MONGODB_OPTIONS={}
+# JWT
+JWT_SECRET=your_jwt_secret
+JWT_EXPIRE=30d
+JWT_COOKIE_EXPIRE=30
+# LemonSqueezy
+LEMON_SQUEEZY_API_KEY=your_api_key
+LEMON_SQUEEZY_STORE_ID=your_store_id
+LEMON_SQUEEZY_WEBHOOK_SECRET=your_webhook_secret
+LEMON_SQUEEZY_BASIC_VARIANT_ID=your_basic_variant_id
+LEMON_SQUEEZY_PRO_VARIANT_ID=your_pro_variant_id
+LEMON_SQUEEZY_ENTERPRISE_VARIANT_ID=your_enterprise_variant_id
+# Redis
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=
+# Email (optional)
+SMTP_HOST=
+SMTP_PORT=
+SMTP_USERNAME=
+SMTP_PASSWORD=
+EMAIL_FROM=</pre>
+            </div>
+        </section>
+        <section class="mb-12">
+            <h2 class="text-2xl font-semibold text-emerald-400 mb-4">Installation & Setup</h2>
+            <div class="mb-6">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">1. Prerequisites</h3>
+                <ul class="list-disc pl-6 space-y-2">
+                    <li>Node.js v16+</li>
+                    <li>MongoDB</li>
+                    <li>Redis</li>
+                    <li>LemonSqueezy account with configured products</li>
+                </ul>
+            </div>
+            <div class="mb-6">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">2. Installation</h3>
+                <div class="code-block">
+                    <pre>
+# Clone the repository
+git clone https://github.com/your-repo/sentimint-backend.git
+cd sentimint-backend
+# Install dependencies
+npm install
+# Create .env file and configure environment variables
+cp .env.example .env
+nano .env
+# Start the server
+npm run dev</pre>
+                </div>
+            </div>
+            <div class="mb-6">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">3. Production Deployment</h3>
+                <div class="code-block">
+                    <pre>
+# Build for production
+npm run build
+# Start in production mode
+npm start
+# Using PM2 (recommended)
+npm install -g pm2
+pm2 start dist/server.js --name sentimint-backend</pre>
+                </div>
+            </div>
+        </section>
+        <section class="mb-12">
+            <h2 class="text-2xl font-semibold text-emerald-400 mb-4">Connecting with React Frontend</h2>
+            <div class="mb-6">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">API Client Setup</h3>
+                <div class="code-block">
+                    <pre>
+// src/api/client.js
+import axios from 'axios';
+const apiClient = axios.create({
+    baseURL: process.env.REACT_APP_API_URL || 'http://localhost:3000/api/v1',
+    withCredentials: true
+});
+// Add request interceptor for JWT
+apiClient.interceptors.request.use((config) => {
+    const token = localStorage.getItem('token');
+    if (token) {
+        config.headers.Authorization = `Bearer ${token}`;
+    }
+    return config;
+});
+// Add response interceptor for error handling
+apiClient.interceptors.response.use(
+    (response) => response,
+    (error) => {
+        if (error.response?.status === 401) {
+            // Handle unauthorized (token expired)
+            localStorage.removeItem('token');
+            window.location.href = '/login';
+        }
+        return Promise.reject(error);
+    }
+);
+export default apiClient;</pre>
+                </div>
+            </div>
+            <div class="mb-6">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">WebSocket Setup</h3>
+                <div class="code-block">
+                    <pre>
+// src/api/websocket.js
+import io from 'socket.io-client';
+let socket;
+export const connectWebSocket = (token) => {
+    socket = io(process.env.REACT_APP_API_URL || 'http://localhost:3000', {
+        auth: { token },
+        transports: ['websocket']
+    });
+    return socket;
+};
+export const disconnectWebSocket = () => {
+    if (socket) {
+        socket.disconnect();
+    }
+};
+export const getSocket = () => socket;</pre>
+                </div>
+            </div>
+            <div class="mb-6">
+                <h3 class="text-xl font-medium text-blue-300 mb-2">Example API Calls</h3>
+                <div class="code-block">
+                    <pre>
+// Example API calls from React frontend
+import apiClient from './client';
+// User registration
+export const register = async (userData) => {
+    const response = await apiClient.post('/auth/register', userData);
+    return response.data;
+};
+// User login
+export const login = async (credentials) => {
+    const response = await apiClient.post('/auth/login', credentials);
+    return response.data;
+};
+// Get user profile
+export const getMe = async () => {
+    const response = await apiClient.get('/users/me');
+    return response.data;
+};
+// Start trading bot
+export const startBot = async (strategy) => {
+    const response = await apiClient.post('/bot/start', { strategy });
+    return response.data;
+};
+// Get trade history
+export const getTrades = async (params) => {
+    const response = await apiClient.get('/bot/trades', { params });
+    return response.data;
+};</pre>
+                </div>
+            </div>
+        </section>
+        <footer class="mt-12 pt-8 border-t border-slate-700 text-center text-slate-400">
+            <p>Sentimint Crypto Trading Bot Backend - Production Ready</p>
+            <p class="mt-2">Designed for seamless integration with React frontend</p>
+            <div class="mt-4 flex justify-center space-x-4">
+                <a href="#" class="text-emerald-400 hover:text-emerald-300">
+                    <i class="fab fa-github"></i> GitHub
+                </a>
+                <a href="#" class="text-emerald-400 hover:text-emerald-300">
+                    <i class="fas fa-book"></i> Documentation
+                </a>
+                <a href="#" class="text-emerald-400 hover:text-emerald-300">
+                    <i class="fas fa-code"></i> API Reference
+                </a>
+            </div>
+        </footer>
+    </div>
 <p style="border-radius: 8px; text-align: center; font-size: 12px; color: #fff; margin-top: 16px;position: fixed; left: 8px; bottom: 8px; z-index: 10; background: rgba(0, 0, 0, 0.8); padding: 4px 8px;">Made with <img src="https://enzostvs-deepsite.hf.space/logo.svg" alt="DeepSite Logo" style="width: 16px; height: 16px; vertical-align: middle;display:inline-block;margin-right:3px;filter:brightness(0) invert(1);"><a href="https://enzostvs-deepsite.hf.space" style="color: #fff;text-decoration: underline;" target="_blank" >DeepSite</a> - 🧬 <a href="https://enzostvs-deepsite.hf.space?remix=Scorpiotur/backend" style="color: #fff;text-decoration: underline;" target="_blank" >Remix</a></p></body>
 </html>