Описание изменений

.cursor/rules/hb3a.mdc

@@ -0,0 +1,29 @@
+---
+description: >
+  Это правило предназначено для управления поведением AI в проекте HB3A. 
+  Оно учитывает специфику работы с различными каналами аутентификации и управления ролями.
+globs:
+  - '**/*.js'  # Применять ко всем JavaScript файлам
+  - '**/*.vue' # Применять ко всем Vue файлам
+  - '!node_modules/**' # Исключить node_modules
+---
+
+# Правила для проекта HB3A
+
+- Учитывайте мультиканальную архитектуру аутентификации (веб, Telegram, Email).
+- Проверяйте наличие токенов управления на балансе крипто кошелька для определения роли пользователя.
+- Обеспечивайте безопасность данных, включая защиту от атак повторного воспроизведения и подделки подписей.
+- Поддерживайте обновленную модель ролей: администратор и клиент, с соответствующими правами и возможностями.
+- Учитывайте дорожную карту разработки и текущие этапы проекта при предложении новых функций или изменений.
+
+# Ссылки на файлы
+
+- @file ../services/auth-service.js
+- @file ../routes/auth.js
+- @file ../middleware/auth.js
+
+# Дополнительные указания
+
+- Используйте комментарии для объяснения сложных участков кода.
+- Предлагайте оптимизации, если код можно улучшить по производительности или безопасности.
+- Объясняйте концепции простым и понятным языком, особенно для новичков.

.cursor/rules/vue-components.mdc

@@ -0,0 +1,27 @@
+---
+description: >
+  Это правило предназначено для управления поведением AI при работе с компонентами Vue.js.
+  Оно учитывает специфику работы с Vue и помогает поддерживать единообразие в проекте.
+globs:
+  - '**/*.vue' # Применять ко всем Vue файлам
+  - '!node_modules/**' # Исключить node_modules
+---
+
+# Правила для компонентов Vue.js
+
+- Следуйте соглашениям об именовании компонентов (PascalCase для имен файлов и компонентов).
+- Используйте шаблоны, скрипты и стили в одном файле для каждого компонента.
+- Обеспечивайте реактивность данных с помощью Vue Composition API или Options API.
+- Используйте директивы Vue (v-if, v-for, v-bind и т.д.) для управления отображением.
+- Поддерживайте чистоту и читаемость кода, используя комментарии для сложных участков.
+
+# Ссылки на файлы
+
+- @file ../components/ExampleComponent.vue
+- @file ../views/ExampleView.vue
+
+# Дополнительные указания
+
+- Объясняйте концепции Vue.js простым и понятным языком.
+- Предлагайте оптимизации, если код можно улучшить по производительности или безопасности.
+- Учитывайте лучшие практики Vue.js при предложении изменений. 

backend/app.js

@@ -1,405 +1,101 @@
 const express = require('express');
 const cors = require('cors');
 const session = require('express-session');
-const { verifySignature, findOrCreateUser } = require('./utils/auth');
 const pgSession = require('connect-pg-simple')(session);
-const { requireRole } = require('./middleware/auth');
-const crypto = require('crypto');
-const path = require('path');
-const fs = require('fs');
-const { router: authRouter } = require('./routes/auth');
 const { pool } = require('./db');
-const FileStore = require('session-file-store')(session);
 const helmet = require('helmet');
-const sessionMiddleware = require('./middleware/session');
+const path = require('path');
-const chatRouter = require('./routes/chat');
+const logger = require('./utils/logger');
+const authService = require('./services/auth-service');
+
+// Импорт маршрутов
+const authRoutes = require('./routes/auth');
+const accessRoutes = require('./routes/access');
 const usersRoutes = require('./routes/users');
 const contractsRoutes = require('./routes/contracts');
 const rolesRoutes = require('./routes/roles');
+const identitiesRoutes = require('./routes/identities');
+// const conversationsRoutes = require('./routes/conversations');
+const messagesRoutes = require('./routes/messages');
+const chatRoutes = require('./routes/chat');
+const healthRoutes = require('./routes/health');
+const debugRoutes = require('./routes/debug');
 
 const app = express();
 
-// Функция для генерации nonce
+// Настройка middleware для сессий
-function generateNonce() {
+app.use(session({
-  return crypto.randomBytes(16).toString('hex');
+  store: new pgSession({
-}
+    pool,
+    tableName: 'session',
+    createTableIfMissing: true,
+  }),
+  secret: process.env.SESSION_SECRET || 'your-secret-key',
+  resave: false,
+  saveUninitialized: true,
+  cookie: {
+    maxAge: 30 * 24 * 60 * 60 * 1000, // 30 дней
+    httpOnly: true,
+    secure: false,
+    sameSite: 'lax',
+  },
+}));
 
-// Парсинг JSON - должен быть до всех роутов
+// Настройка парсеров
 app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
 
-// Настройка CORS
+// Настройка CORS (должна быть после настройки сессий)
-app.use(
+app.use(cors({
-  cors({
+  origin: function(origin, callback) {
-    origin: function(origin, callback) {
+    // Разрешаем запросы с localhost и 127.0.0.1
-      // Разрешаем запросы с любого источника в режиме разработки
+    const allowedOrigins = [
-      const allowedOrigins = ['http://localhost:3000', 'http://127.0.0.1:5173', 'http://localhost:5173'];
+      'http://localhost:5173',
-      if (!origin || allowedOrigins.indexOf(origin) !== -1) {
+      'http://127.0.0.1:5173',
-        callback(null, true);
+      'http://localhost:3000',
-      } else {
+      'http://127.0.0.1:3000',
-        callback(new Error('Not allowed by CORS'));
+      process.env.CORS_ORIGIN
-      }
+    ].filter(Boolean);
-    },
-    credentials: true,
-    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-    allowedHeaders: ['Content-Type', 'Authorization', 'X-Auth-Nonce'],
-  })
-);
     
-// Настройка сессий
+    if (!origin || allowedOrigins.includes(origin)) {
-app.use(
+      callback(null, true);
-  session({
-    store: new pgSession({
-      pool: pool,
-      tableName: 'sessions',
-      createTableIfMissing: false,
-    }),
-    secret: process.env.SESSION_SECRET || 'your-secret-key',
-    resave: false,
-    saveUninitialized: true,
-    name: 'dapp.sid',
-    cookie: {
-      secure: false,
-      httpOnly: true,
-      maxAge: 30 * 24 * 60 * 60 * 1000,
-      sameSite: 'lax',
-    },
-  })
-);
-
-// Middleware для безопасности
-app.use(
-  helmet({
-    contentSecurityPolicy: false, // Отключаем CSP для разработки
-  })
-);
-
-// Middleware для логирования
-app.use((req, res, next) => {
-  console.log(`${req.method} ${req.path}`, {
-    headers: req.headers,
-    body: req.body,
-    session: req.session,
-  });
-  next();
-});
-
-// Middleware для сохранения сессии после каждого запроса
-app.use((req, res, next) => {
-  const originalEnd = res.end;
-
-  res.end = function () {
-    if (req.session && req.session.save) {
-      req.session.save((err) => {
-        if (err) {
-          console.error('Ошибка при сохранении сессии:', err);
-        }
-        originalEnd.apply(res, arguments);
-      });
     } else {
-      originalEnd.apply(res, arguments);
+      callback(new Error('Not allowed by CORS'));
     }
-  };
+  },
+  credentials: true
+}));
 
+// Настройка безопасности
+app.use(helmet({
+  contentSecurityPolicy: false // Отключаем CSP для разработки
+}));
+
+// Логирование запросов
+app.use((req, res, next) => {
+  logger.info(`${req.method} ${req.url}`);
   next();
 });
 
-// Middleware для проверки авторизации
+// Маршруты API
-const requireAuth = (req, res, next) => {
+app.use('/api/auth', authRoutes);
-  console.log('Auth check:', {
+app.use('/api/access', accessRoutes);
-    session: req.session,
-    authenticated: req.session.authenticated,
-    address: req.session.address,
-  });
-
-  if (!req.session.authenticated || !req.session.address) {
-    return res.status(401).json({ error: 'Unauthorized' });
-  }
-  next();
-};
-
-// Миддлвар для обновления дополнительных полей в таблице sessions
-app.use(async (req, res, next) => {
-  try {
-    // Если есть адрес, но нет userId, найдем или создадим пользователя
-    if (req.session && req.session.authenticated && req.session.address && !req.session.userId) {
-      try {
-        const user = await findOrCreateUser(req.session.address, 'wallet');
-        req.session.userId = user.id;
-        req.session.role = user.role;
-        req.session.isAdmin = user.is_admin;
-        
-        // Стандартизируем данные сессии
-        standardizeSessionData(req);
-        
-        // Сохраняем обновленную сессию
-        await new Promise((resolve, reject) => {
-          req.session.save(err => {
-            if (err) reject(err);
-            else resolve();
-          });
-        });
-      } catch (err) {
-        console.error('Ошибка при обновлении userId в сессии:', err);
-      }
-    }
-    
-    // Обновляем поля в таблице sessions
-    if (req.session && (req.session.userId || req.session.address)) {
-      db.query(
-        'UPDATE sessions SET last_activity = NOW(), user_id = $1, auth_channel = $2, language = $3 WHERE sid = $4',
-        [
-          req.session.userId || null,
-          req.session.authChannel || 'web',
-          req.session.language || 'en',
-          req.sessionID
-        ]
-      ).catch(err => console.error('Error updating session data:', err));
-    }
-  } catch (err) {
-    console.error('Ошибка в middleware сессий:', err);
-  }
-  
-  next();
-});
-
-// Функция для стандартизации данных сессии
-function standardizeSessionData(req) {
-  if (req.session.authenticated) {
-    // Убедимся, что все необходимые поля присутствуют
-    req.session.authType = req.session.authType || 'wallet';
-    req.session.role = req.session.role || 'USER';
-    req.session.isAdmin = !!req.session.isAdmin;
-    req.session.authChannel = req.session.authChannel || 'web';
-    req.session.language = req.session.language || 'en';
-  }
-}
-
-// API роуты
-const apiRouter = express.Router();
-
-// Удалите или закомментируйте этот блок кода
-/*
-apiRouter.post('/refresh-session', async (req, res) => {
-  try {
-    const { address, signature } = req.body;
-    
-    if (!address || !signature) {
-      return res.status(400).json({ error: 'Missing required fields' });
-    }
-
-    // Проверяем подпись
-    const verified = await verifySignature(
-      { address }, // упрощенное сообщение для проверки
-      signature,
-      address
-    );
-
-    if (!verified) {
-      return res.status(401).json({ error: 'Invalid signature' });
-    }
-
-    // Обновляем сессию
-    req.session.authenticated = true;
-    req.session.address = address;
-    req.session.lastSignature = signature;
-
-    // Сохраняем сессию
-    req.session.save((err) => {
-      if (err) {
-        console.error('Session refresh error:', err);
-        return res.status(500).json({ error: 'Session refresh failed' });
-      }
-
-      console.log('Session refreshed:', {
-        id: req.sessionID,
-        address: address,
-        authenticated: true
-      });
-
-      res.json({ success: true });
-    });
-  } catch (error) {
-    console.error('Session refresh error:', error);
-    res.status(500).json({ error: 'Internal server error' });
-  }
-});
-*/
-
-apiRouter.get('/session', (req, res) => {
-  console.log('Session check:', {
-    session: req.session,
-    authenticated: req.session.authenticated,
-    address: req.session.address,
-  });
-
-  res.json({
-    authenticated: !!req.session.authenticated,
-    address: req.session.address || null,
-  });
-});
-
-// Обновим роут для выхода
-apiRouter.post('/signout', (req, res) => {
-  try {
-    req.session.destroy();
-    res.clearCookie('connect.sid'); // Теперь это правильное имя cookie
-    res.json({ success: true });
-  } catch (error) {
-    console.error('Signout error:', error);
-    res.status(500).json({ error: 'Internal server error' });
-  }
-});
-
-// Проверка прав администратора
-apiRouter.get('/admin/check', async (req, res) => {
-  try {
-    if (!req.session || !req.session.address) {
-      return res.json({ isAdmin: false });
-    }
-
-    // Проверяем является ли адрес владельцем контракта
-    const ethers = require('ethers');
-    const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_NETWORK_URL);
-    const contractABI = require('./artifacts/contracts/MyContract.sol/MyContract.json').abi;
-    const contract = new ethers.Contract(process.env.CONTRACT_ADDRESS, contractABI, provider);
-
-    const contractOwner = await contract.owner();
-    const isAdmin = req.session.address.toLowerCase() === contractOwner.toLowerCase();
-
-    res.json({ isAdmin });
-  } catch (error) {
-    console.error('Admin check error:', error);
-    res.status(500).json({ error: error.message });
-  }
-});
-
-// Только для админов
-apiRouter.post('/api/admin/action', requireRole('ADMIN'), (req, res) => {
-  // ...
-});
-
-// Для модераторов и админов
-apiRouter.post('/api/moderate/action', requireRole('MODERATOR'), (req, res) => {
-  // ...
-});
-
-// Для всех с токеном
-apiRouter.post('/api/protected/action', requireRole(), (req, res) => {
-  // ...
-});
-
-// Обновим роут для верификации
-apiRouter.post('/verify', async (req, res) => {
-  try {
-    console.log('Получен запрос на верификацию в app.js:', req.body);
-    const { message, signature } = req.body;
-
-    if (!message || !signature) {
-      console.error('Отсутствуют необходимые поля:', {
-        message: !!message,
-        signature: !!signature,
-      });
-      return res.status(400).json({ success: false, error: 'Missing required fields' });
-    }
-
-    // Проверяем, что message содержит адрес
-    if (!message.address) {
-      console.error('Отсутствует адрес в сообщении');
-      return res.status(400).json({ success: false, error: 'Missing address in message' });
-    }
-
-    // Получаем адрес из сообщения напрямую
-    const address = message.address;
-    console.log('Адрес из сообщения:', address);
-
-    // Устанавливаем сессию без проверки подписи
-    req.session.authenticated = true;
-    req.session.address = address;
-    req.session.lastSignature = signature;
-
-    // Сохраняем сессию
-    req.session.save((err) => {
-      if (err) {
-        console.error('Ошибка при сохранении сессии:', err);
-        return res.status(500).json({
-          success: false,
-          error: 'Session save failed',
-          message: err.message,
-        });
-      }
-
-      console.log('Сессия сохранена успешно:', req.sessionID);
-      return res.json({ success: true, address, isAdmin: true });
-    });
-  } catch (error) {
-    console.error('Подробная ошибка при верификации:', error.stack);
-    console.error('Verification error:', error);
-    res.status(500).json({
-      success: false,
-      error: 'Verification failed',
-      message: error.message || 'Unknown error',
-    });
-  }
-});
-
-// Монтируем API роуты
-app.use('/api', apiRouter);
-
-// Подключаем маршруты аутентификации
-app.use('/api/auth', authRouter);
 app.use('/api/users', usersRoutes);
 app.use('/api/contracts', contractsRoutes);
-app.use('/api/chat', chatRouter);
 app.use('/api/roles', rolesRoutes);
+app.use('/api/identities', identitiesRoutes);
+// app.use('/api/conversations', conversationsRoutes);
+app.use('/api/messages', messagesRoutes);
+app.use('/api/chat', chatRoutes);
+app.use('/api/health', healthRoutes);
 
-apiRouter.get('/nonce', (req, res) => {
+// Маршруты для отладки (только в режиме разработки)
-  const nonce = generateNonce();
+if (process.env.NODE_ENV !== 'production') {
-  console.log('Generated new nonce:', nonce);
+  app.use('/api/debug', debugRoutes);
+}
 
-  // Сохраняем nonce в сессии
+const nonceStore = new Map(); // или любая другая реализация хранилища nonce
-  if (!req.session.nonces) {
-    req.session.nonces = [];
-  }
-  req.session.nonces.push(nonce);
 
-  // Ограничиваем количество nonce в сессии
+console.log('SESSION_SECRET:', process.env.SESSION_SECRET);
-  if (req.session.nonces.length > 5) {
-    req.session.nonces.shift();
-  }
 
-  console.log('Nonces in session:', req.session.nonces);
+module.exports = { app, nonceStore };
-
-  res.json({ nonce });
-});
-
-// Добавьте после настройки сессий
-app.use(sessionMiddleware);
-
-// Обработка ошибок сессий
-app.use((err, req, res, next) => {
-  if (err.code === 'ENOENT' && err.message.includes('sessions')) {
-    console.error('Session error:', err);
-    // Пересоздаем сессию
-    req.session.regenerate((regenerateErr) => {
-      if (regenerateErr) {
-        console.error('Failed to regenerate session:', regenerateErr);
-        return res.status(500).json({ error: 'Session error' });
-      }
-      next();
-    });
-  } else {
-    next(err);
-  }
-});
-
-// Обработка ошибок
-app.use((err, req, res, next) => {
-  console.error(err.stack);
-  res.status(500).json({ error: 'Something broke!' });
-});
-
-// Подключаем маршруты для отладки
-const debugRouter = require('./routes/debug');
-app.use('/api/debug', debugRouter);
-
-module.exports = { app };

backend/contracts/AccessToken.sol

@@ -10,7 +10,7 @@ contract AccessToken is ERC721, Ownable {
     Counters.Counter private _tokenIds;
 
     // Роли для токенов
-    enum Role { ADMIN, MODERATOR, SUPPORT }
+    enum Role { USER, ADMIN }
     
     // Маппинг токен ID => роль
     mapping(uint256 => Role) public tokenRoles;
@@ -24,6 +24,8 @@ contract AccessToken is ERC721, Ownable {
 
     // Создание нового токена доступа
     function mintAccessToken(address to, Role role) public onlyOwner {
+        require(role == Role.USER || role == Role.ADMIN, "Invalid role");
+        
         _tokenIds.increment();
         uint256 newTokenId = _tokenIds.current();
         
@@ -51,10 +53,9 @@ contract AccessToken is ERC721, Ownable {
     function _beforeTokenTransfer(
         address from,
         address to,
-        uint256 tokenId,
+        uint256 tokenId
-        uint256 batchSize
     ) internal override {
         require(from == address(0) || to == address(0), "Token transfer not allowed");
-        super._beforeTokenTransfer(from, to, tokenId, batchSize);
+        super._beforeTokenTransfer(from, to, tokenId);
     }
 } 

backend/db/init.js

@@ -0,0 +1,63 @@
+// Инициализация таблицы roles
+async function initRoles() {
+  try {
+    // Проверяем, существует ли таблица roles
+    const tableExists = await db.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_name = 'roles'
+      );
+    `);
+    
+    if (!tableExists.rows[0].exists) {
+      // Создаем таблицу roles
+      await db.query(`
+        CREATE TABLE roles (
+          id SERIAL PRIMARY KEY,
+          name VARCHAR(50) NOT NULL UNIQUE,
+          description TEXT,
+          created_at TIMESTAMP NOT NULL DEFAULT NOW()
+        );
+      `);
+      
+      // Добавляем роли
+      await db.query(`
+        INSERT INTO roles (id, name, description) VALUES 
+        (3, 'user', 'Обычный пользователь'),
+        (4, 'admin', 'Администратор с полным доступом');
+      `);
+      
+      console.log('Таблица roles создана и заполнена');
+    } else {
+      // Проверяем наличие ролей
+      const rolesExist = await db.query(`
+        SELECT COUNT(*) FROM roles WHERE id IN (3, 4);
+      `);
+      
+      if (rolesExist.rows[0].count < 2) {
+        // Добавляем недостающие роли
+        const userRoleExists = await db.query(`SELECT EXISTS (SELECT FROM roles WHERE name = 'user');`);
+        const adminRoleExists = await db.query(`SELECT EXISTS (SELECT FROM roles WHERE name = 'admin');`);
+        
+        if (!userRoleExists.rows[0].exists) {
+          await db.query(`
+            INSERT INTO roles (id, name, description) VALUES 
+            (3, 'user', 'Обычный пользователь');
+          `);
+        }
+        
+        if (!adminRoleExists.rows[0].exists) {
+          await db.query(`
+            INSERT INTO roles (id, name, description) VALUES 
+            (4, 'admin', 'Администратор с полным доступом');
+          `);
+        }
+        
+        console.log('Таблица roles обновлена');
+      }
+    }
+  } catch (error) {
+    console.error('Ошибка при инициализации таблицы roles:', error);
+    throw error;
+  }
+} 

backend/middleware/auth.js

@@ -1,130 +1,132 @@
+const { createError } = require('./errorHandler');
+const authService = require('../services/auth-service');
 const logger = require('../utils/logger');
-const { getUserInfo } = require('../utils/access-check');
+const { USER_ROLES } = require('../utils/constants');
+const db = require('../db');
 
-// Добавьте в начало файла
+/**
-const isMiddleware = true;
+ * Middleware для проверки аутентификации
-
+ */
-// Middleware для проверки роли
+function requireAuth(req, res, next) {
-const requireRole = (allowedRoles) => async (req, res, next) => {
+  console.log('Session in requireAuth:', req.session);
-  if (!req.session || !req.session.authenticated || !req.session.userId) {
+  if (!req.session || !req.session.authenticated) {
-    return res.status(401).json({ error: 'Требуется аутентификация' });
+    return next(createError(401, 'Требуется аутентификация'));
   }
+  next();
+}
 
+/**
+ * Middleware для проверки прав администратора
+ */
+async function requireAdmin(req, res, next) {
   try {
-    // Получение информации о пользователе
+    // Проверка аутентификации
-    const userInfo = await getUserInfo(req.session.userId);
+    if (!req.session || !req.session.authenticated) {
-    
+      return next(createError('Требуется аутентификация', 401));
-    if (!userInfo) {
-      return res.status(401).json({ error: 'Пользователь не найден' });
     }
 
-    // Проверка роли
+    // Проверка через сессию
-    if (!allowedRoles.includes(userInfo.role)) {
+    if (req.session.isAdmin) {
-      return res.status(403).json({ error: 'Недостаточно прав' });
+      return next();
     }
 
-    next();
+    // Проверка через кошелек
-  } catch (error) {
-    logger.error('Error checking user role:', error);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
-  }
-};
-
-// Проверка роли пользователя
-const checkRole = async (req, res, next) => {
-  try {
-    // Если функция вызвана как middleware
-    const isMiddleware = typeof next === 'function';
-
-    if (!req.session.authenticated) {
-      return isMiddleware ? res.status(401).json({ error: 'Не авторизован' }) : false;
-    }
-
-    // Если роль администратора уже проверена в сессии
-    if (req.session.isAdmin === true) {
-      return isMiddleware ? next() : true;
-    }
-
-    const db = require('../db');
-
-    // Проверка наличия токенов доступа в смарт-контракте
     if (req.session.address) {
-      const address = req.session.address.toLowerCase();
+      const isAdmin = await authService.checkAdminToken(req.session.address);
-
+      if (isAdmin) {
-      // Проверка в базе данных
+        // Обновляем сессию
-      const userRole = await db.query(
-        'SELECT r.name FROM users u JOIN roles r ON u.role_id = r.id WHERE LOWER(u.address) = $1',
-        [address]
-      );
-
-      if (userRole.rows.length > 0 && userRole.rows[0].name === 'admin') {
         req.session.isAdmin = true;
-        return isMiddleware ? next() : true;
+        return next();
-      }
-
-      // Проверка токенов в смарт-контракте через сервис
-      const { ethers } = require('ethers');
-      const provider = new ethers.JsonRpcProvider(process.env.PROVIDER_URL);
-      const accessTokenABI = require('../artifacts/contracts/AccessToken.sol/AccessToken.json').abi;
-      const accessTokenContract = new ethers.Contract(
-        process.env.ACCESS_TOKEN_ADDRESS,
-        accessTokenABI,
-        provider
-      );
-
-      try {
-        const hasAdminRole = await accessTokenContract.hasRole(
-          ethers.keccak256(ethers.toUtf8Bytes('ADMIN_ROLE')),
-          address
-        );
-
-        if (hasAdminRole) {
-          // Обновляем роль в базе данных
-          await db.query(
-            'UPDATE users SET role_id = (SELECT id FROM roles WHERE name = $1) WHERE LOWER(address) = $2',
-            ['admin', address]
-          );
-          req.session.isAdmin = true;
-          return isMiddleware ? next() : true;
-        }
-      } catch (error) {
-        console.error('Ошибка при проверке роли в контракте:', error);
       }
     }
 
-    // Если пользователь не администратор
+    // Проверка через ID пользователя
-    req.session.isAdmin = false;
+    if (req.session.userId) {
-    return isMiddleware ? res.status(403).json({ error: 'Недостаточно прав' }) : false;
+      const userResult = await db.query('SELECT role FROM users WHERE id = $1', [req.session.userId]);
+      if (userResult.rows.length > 0 && userResult.rows[0].role === USER_ROLES.ADMIN) {
+        // Обновляем сессию
+        req.session.isAdmin = true;
+        return next();
+      }
+    }
+
+    // Если ни одна проверка не прошла
+    return next(createError('Доступ запрещен', 403));
   } catch (error) {
-    console.error('Ошибка при проверке роли:', error);
+    logger.error(`Error in requireAdmin middleware: ${error.message}`);
-    return isMiddleware ? res.status(500).json({ error: 'Внутренняя ошибка сервера' }) : false;
+    return next(createError('Внутренняя ошибка сервера', 500));
   }
-};
+}
 
-// Middleware для проверки аутентификации
+/**
-const requireAuth = (req, res, next) => {
+ * Middleware для проверки определенной роли
-  if (!req.session || !req.session.authenticated) {
+ * @param {string} role - Требуемая роль
-    return res.status(401).json({ error: 'Требуется аутентификация' });
+ */
-  }
+function requireRole(role) {
-  next();
+  return async (req, res, next) => {
-};
+    try {
+      // Проверка аутентификации
+      if (!req.session || !req.session.authenticated) {
+        return next(createError('Требуется аутентификация', 401));
+      }
 
-// Middleware для проверки прав администратора
+      // Для администраторов разрешаем все
-const requireAdmin = (req, res, next) => {
+      if (req.session.isAdmin) {
-  if (!req.session || !req.session.authenticated) {
+        return next();
-    return res.status(401).json({ error: 'Требуется аутентификация' });
+      }
-  }
 
-  if (!req.session.isAdmin) {
+      // Проверка через ID пользователя
-    return res.status(403).json({ error: 'Требуются права администратора' });
+      if (req.session.userId) {
-  }
+        const userResult = await db.query('SELECT role FROM users WHERE id = $1', [req.session.userId]);
+        if (userResult.rows.length > 0 && userResult.rows[0].role === role) {
+          return next();
+        }
+      }
 
-  next();
+      // Если проверка не прошла
-};
+      return next(createError('Доступ запрещен', 403));
+    } catch (error) {
+      logger.error(`Error in requireRole middleware: ${error.message}`);
+      return next(createError('Внутренняя ошибка сервера', 500));
+    }
+  };
+}
+
+/**
+ * Проверяет роль пользователя
+ * @param {string} role - Роль для проверки
+ */
+function checkRole(role) {
+  return async (req, res, next) => {
+    try {
+      // Если пользователь не аутентифицирован, просто продолжаем
+      if (!req.session || !req.session.authenticated) {
+        req.hasRole = false;
+        return next();
+      }
+
+      // Проверка через ID пользователя
+      if (req.session.userId) {
+        const userResult = await db.query('SELECT role FROM users WHERE id = $1', [req.session.userId]);
+        if (userResult.rows.length > 0 && userResult.rows[0].role === role) {
+          req.hasRole = true;
+          return next();
+        }
+      }
+
+      req.hasRole = false;
+      next();
+    } catch (error) {
+      logger.error(`Error in checkRole middleware: ${error.message}`);
+      req.hasRole = false;
+      next();
+    }
+  };
+}
 
 module.exports = {
-  requireRole,
   requireAuth,
   requireAdmin,
-  checkRole,
+  requireRole,
+  checkRole
 };

backend/middleware/errorHandler.js

@@ -0,0 +1,71 @@
+const logger = require('../utils/logger');
+const { ERROR_CODES } = require('../utils/constants');
+
+/**
+ * Middleware для обработки ошибок
+ */
+function errorHandler(err, req, res, next) {
+  // Логируем ошибку
+  logger.error(`Error: ${err.message}`, {
+    stack: err.stack,
+    url: req.originalUrl,
+    method: req.method,
+    ip: req.ip,
+    userId: req.session?.userId
+  });
+
+  // Определяем тип ошибки
+  let statusCode = 500;
+  let errorCode = ERROR_CODES.INTERNAL_ERROR;
+  let errorMessage = 'Внутренняя ошибка сервера';
+
+  // Обрабатываем разные типы ошибок
+  if (err.name === 'UnauthorizedError' || err.status === 401) {
+    statusCode = 401;
+    errorCode = ERROR_CODES.UNAUTHORIZED;
+    errorMessage = 'Требуется аутентификация';
+  } else if (err.status === 403) {
+    statusCode = 403;
+    errorCode = ERROR_CODES.FORBIDDEN;
+    errorMessage = 'Доступ запрещен';
+  } else if (err.status === 404) {
+    statusCode = 404;
+    errorCode = ERROR_CODES.NOT_FOUND;
+    errorMessage = 'Ресурс не найден';
+  } else if (err.status === 400) {
+    statusCode = 400;
+    errorCode = ERROR_CODES.BAD_REQUEST;
+    errorMessage = err.message || 'Некорректный запрос';
+  }
+
+  // В режиме разработки возвращаем стек ошибки
+  const devError = process.env.NODE_ENV === 'development' 
+    ? { stack: err.stack } 
+    : {};
+
+  // Отправляем ответ клиенту
+  res.status(statusCode).json({
+    error: {
+      code: errorCode,
+      message: errorMessage,
+      ...devError
+    }
+  });
+}
+
+/**
+ * Функция для создания ошибок с определенным статусом
+ * @param {string} message - Сообщение об ошибке
+ * @param {number} status - HTTP-статус ошибки
+ * @returns {Error} - Объект ошибки
+ */
+function createError(message, status) {
+  const error = new Error(message);
+  error.status = status;
+  return error;
+}
+
+module.exports = {
+  errorHandler,
+  createError
+}; 

backend/middleware/errorMiddleware.js

@@ -0,0 +1,56 @@
+const logger = require('../utils/logger');
+const { ERROR_CODES } = require('../utils/constants');
+
+/**
+ * Middleware для обработки ошибок
+ */
+function errorMiddleware(err, req, res, next) {
+  // Логируем ошибку
+  logger.error(`Error: ${err.message}`, {
+    stack: err.stack,
+    url: req.originalUrl,
+    method: req.method,
+    ip: req.ip,
+    userId: req.session?.userId
+  });
+
+  // Определяем тип ошибки
+  let statusCode = 500;
+  let errorCode = ERROR_CODES.INTERNAL_ERROR;
+  let errorMessage = 'Внутренняя ошибка сервера';
+
+  // Обрабатываем разные типы ошибок
+  if (err.name === 'UnauthorizedError' || err.status === 401) {
+    statusCode = 401;
+    errorCode = ERROR_CODES.UNAUTHORIZED;
+    errorMessage = 'Требуется аутентификация';
+  } else if (err.status === 403) {
+    statusCode = 403;
+    errorCode = ERROR_CODES.FORBIDDEN;
+    errorMessage = 'Доступ запрещен';
+  } else if (err.status === 404) {
+    statusCode = 404;
+    errorCode = ERROR_CODES.NOT_FOUND;
+    errorMessage = 'Ресурс не найден';
+  } else if (err.status === 400) {
+    statusCode = 400;
+    errorCode = ERROR_CODES.BAD_REQUEST;
+    errorMessage = err.message || 'Некорректный запрос';
+  }
+
+  // В режиме разработки возвращаем стек ошибки
+  const devError = process.env.NODE_ENV === 'development' 
+    ? { stack: err.stack } 
+    : {};
+
+  // Отправляем ответ клиенту
+  res.status(statusCode).json({
+    error: {
+      code: errorCode,
+      message: errorMessage,
+      ...devError
+    }
+  });
+}
+
+module.exports = errorMiddleware; 

backend/middleware/logger.js

@@ -1,12 +1,14 @@
-const logger = (req, res, next) => {
+const logger = require('../utils/logger');
+
+const requestLogger = (req, res, next) => {
   const start = Date.now();
 
   res.on('finish', () => {
     const duration = Date.now() - start;
-    console.log(`${req.method} ${req.originalUrl} - ${res.statusCode} - ${duration}ms`);
+    logger.info(`${req.method} ${req.originalUrl} - ${res.statusCode} - ${duration}ms`);
   });
 
   next();
 };
 
-module.exports = logger;
+module.exports = requestLogger; 

backend/middleware/session.js

@@ -4,18 +4,18 @@ const { pool } = require('../db');
 
 const sessionMiddleware = session({
   store: new pgSession({
-    pool: pool,
+    pool,
     tableName: 'session',
     createTableIfMissing: true,
   }),
   secret: process.env.SESSION_SECRET || 'your-secret-key',
   resave: false,
-  saveUninitialized: false,
+  saveUninitialized: true,
   cookie: {
-    secure: process.env.NODE_ENV === 'production', // В production должно быть true
+    maxAge: 30 * 24 * 60 * 60 * 1000, // 30 дней
     httpOnly: true,
-    maxAge: 24 * 60 * 60 * 1000, // 24 часа
+    secure: process.env.NODE_ENV === 'production', // В production должно быть true
-    sameSite: 'none', // Для работы между разными доменами
+    sameSite: 'lax', // Попробуйте изменить на 'none' если используете разные домены
   },
 });
 

backend/package.json

@@ -24,14 +24,15 @@
     "@langchain/community": "^0.3.34",
     "@langchain/core": "0.3.0",
     "@langchain/ollama": "^0.2.0",
+    "@openzeppelin/contracts": "4.5.0",
     "axios": "^1.6.7",
     "connect-pg-simple": "^10.0.0",
     "cors": "^2.8.5",
     "cron": "^4.1.0",
     "csurf": "^1.11.0",
     "dotenv": "^16.0.3",
-    "ethers": "6.13.5",
+    "ethers": "^6.13.5",
-    "express": "^4.18.2",
+    "express": "^4.21.2",
     "express-rate-limit": "^7.5.0",
     "express-session": "^1.17.3",
     "helmet": "^8.0.0",
@@ -48,10 +49,29 @@
     "winston": "^3.17.0"
   },
   "devDependencies": {
+    "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
+    "@nomicfoundation/hardhat-ignition": "^0.15.10",
+    "@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "@nomicfoundation/hardhat-verify": "^2.0.0",
+    "@nomicfoundation/ignition-core": "^0.15.10",
+    "@typechain/ethers-v6": "^0.5.0",
+    "@typechain/hardhat": "^9.0.0",
+    "@types/chai": "^4.2.0",
+    "@types/mocha": ">=9.1.0",
+    "chai": "^4.2.0",
     "eslint": "^9.21.0",
     "eslint-config-prettier": "^10.0.2",
     "globals": "^16.0.0",
+    "hardhat": "^2.22.19",
+    "hardhat-gas-reporter": "^1.0.8",
     "nodemon": "^3.1.9",
-    "prettier": "^3.5.3"
+    "prettier": "^3.5.3",
+    "solidity-coverage": "^0.8.1",
+    "ts-node": ">=8.0.0",
+    "typechain": "^8.3.0",
+    "typescript": ">=4.5.0"
   }
 }

backend/routes/access.js

@@ -4,43 +4,24 @@ const { Pool } = require('pg');
 const { requireAuth, requireAdmin } = require('../middleware/auth');
 const db = require('../db');
 const { ethers } = require('ethers');
-
+const authService = require('../services/auth-service');
-// Подключение к БД
+const logger = require('../utils/logger');
-const pool = new Pool({
-  connectionString: process.env.DATABASE_URL,
-  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
-});
 
 // Проверка доступа
 router.get('/check', async (req, res) => {
-  const walletAddress = req.headers['x-wallet-address'];
-
-  if (!walletAddress) {
-    return res.status(400).json({ error: 'No wallet address provided' });
-  }
-
   try {
-    // Проверяем наличие активного токена для адреса
+    const { address } = req.query;
-    const result = await pool.query(
-      'SELECT * FROM access_tokens WHERE wallet_address = $1 AND expires_at > NOW()',
-      [walletAddress.toLowerCase()]
-    );
     
-    if (result.rows.length === 0) {
+    if (!address) {
-      return res.json({ hasAccess: false });
+      return res.status(400).json({ error: 'Address is required' });
     }
     
-    const token = result.rows[0];
+    const isAdmin = await authService.checkAdminToken(address);
     
-    res.json({
+    res.json({ isAdmin });
-      hasAccess: true,
-      tokenId: token.id,
-      role: token.role,
-      expiresAt: token.expires_at,
-    });
   } catch (error) {
-    console.error('Access check error:', error);
+    logger.error(`Error checking access: ${error.message}`);
-    res.status(500).json({ error: error.message });
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
@@ -63,40 +44,14 @@ router.get('/admin-only', async (req, res) => {
   }
 });
 
-// Получение списка токенов
+// Получение всех токенов доступа
 router.get('/tokens', async (req, res) => {
-  const walletAddress = req.headers['x-wallet-address'];
-
-  if (!walletAddress) {
-    return res.status(400).json({ error: 'No wallet address provided' });
-  }
-
   try {
-    // Проверяем права администратора
+    const tokens = await authService.getAllTokens();
-    const adminCheck = await pool.query(
+    res.json(tokens);
-      'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
-      [walletAddress.toLowerCase(), 'ADMIN']
-    );
-
-    if (adminCheck.rows.length === 0) {
-      return res.status(403).json({ error: 'Access denied' });
-    }
-
-    // Получаем список всех токенов
-    const result = await pool.query('SELECT * FROM access_tokens ORDER BY created_at DESC');
-
-    res.json(
-      result.rows.map((token) => ({
-        id: token.id,
-        walletAddress: token.wallet_address,
-        role: token.role,
-        createdAt: token.created_at,
-        expiresAt: token.expires_at,
-      }))
-    );
   } catch (error) {
-    console.error('Tokens list error:', error);
+    logger.error(`Error getting tokens: ${error.message}`);
-    res.status(500).json({ error: error.message });
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
@@ -110,12 +65,9 @@ router.post('/tokens', async (req, res) => {
 
   try {
     // Проверяем права администратора
-    const adminCheck = await pool.query(
+    const isAdmin = await authService.checkAdminToken(walletAddress);
-      'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
-      [walletAddress.toLowerCase(), 'ADMIN']
-    );
 
-    if (adminCheck.rows.length === 0) {
+    if (!isAdmin) {
       return res.status(403).json({ error: 'Access denied' });
     }
 
@@ -130,7 +82,7 @@ router.post('/tokens', async (req, res) => {
     expiresAt.setDate(expiresAt.getDate() + parseInt(expiresInDays));
 
     // Создаем токен
-    const result = await pool.query(
+    const result = await db.query(
       'INSERT INTO access_tokens (wallet_address, role, expires_at) VALUES ($1, $2, $3) RETURNING *',
       [targetAddress.toLowerCase(), role, expiresAt]
     );
@@ -158,19 +110,16 @@ router.delete('/tokens/:id', async (req, res) => {
 
   try {
     // Проверяем права администратора
-    const adminCheck = await pool.query(
+    const isAdmin = await authService.checkAdminToken(walletAddress);
-      'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
-      [walletAddress.toLowerCase(), 'ADMIN']
-    );
 
-    if (adminCheck.rows.length === 0) {
+    if (!isAdmin) {
       return res.status(403).json({ error: 'Access denied' });
     }
 
     const { id } = req.params;
 
     // Удаляем токен
-    await pool.query('DELETE FROM access_tokens WHERE id = $1', [id]);
+    await db.query('DELETE FROM access_tokens WHERE id = $1', [id]);
 
     res.json({ success: true });
   } catch (error) {
@@ -182,118 +131,95 @@ router.delete('/tokens/:id', async (req, res) => {
 // Получение информации о роли текущего пользователя
 router.get('/role', requireAuth, async (req, res) => {
   try {
-    const address = req.session.address.toLowerCase();
+    const role = await authService.getUserRole(req.user.id);
-
+    return res.json({ role });
-    const result = await db.query(
-      'SELECT r.name as role FROM users u JOIN roles r ON u.role_id = r.id WHERE LOWER(u.address) = $1',
-      [address]
-    );
-
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'Пользователь не найден' });
-    }
-
-    return res.json({ role: result.rows[0].role });
   } catch (error) {
-    console.error('Ошибка при получении роли:', error);
+    logger.error('Ошибка при получении роли:', error);
     return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
   }
 });
 
 // Получение списка всех пользователей (только для администраторов)
-router.get('/users', requireAdmin, async (req, res) => {
+router.get('/users', requireAuth, requireAdmin, async (req, res) => {
   try {
-    const result = await db.query(
+    const result = await db.query(`
-      'SELECT u.id, u.wallet_address, r.name as role, u.created_at FROM users u JOIN roles r ON u.role_id = r.id'
+      SELECT u.id, ui.identity_value as wallet_address, r.name as role, u.created_at 
-    );
+      FROM users u 
+      JOIN roles r ON u.role_id = r.id
+      LEFT JOIN user_identities ui ON u.id = ui.user_id AND ui.identity_type = 'wallet'
+    `);
 
     return res.json(result.rows);
   } catch (error) {
-    console.error('Ошибка при получении списка пользователей:', error);
+    logger.error('Ошибка при получении списка пользователей:', error);
     return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
   }
 });
 
-// Изменение роли пользователя (только для администраторов)
+// Обновление роли пользователя
-router.post('/users/:userId/role', requireAdmin, async (req, res) => {
+router.post('/update-role', async (req, res) => {
   try {
-    const { userId } = req.params;
+    const { userId, role } = req.body;
-    const { role } = req.body;
     
-    if (!role || !['admin', 'user'].includes(role)) {
+    if (!userId || !role) {
-      return res.status(400).json({ error: 'Некорректная роль' });
+      return res.status(400).json({ error: 'User ID and role are required' });
     }
     
-    await db.query(
+    const success = await authService.updateUserRole(userId, role);
-      'UPDATE users SET role_id = (SELECT id FROM roles WHERE name = $1) WHERE id = $2',
-      [role, userId]
-    );
     
-    return res.json({ success: true });
+    if (success) {
+      res.json({ success: true });
+    } else {
+      res.status(400).json({ error: 'Failed to update role' });
+    }
   } catch (error) {
-    console.error('Ошибка при изменении роли пользователя:', error);
+    logger.error(`Error updating role: ${error.message}`);
-    return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
-// Получение информации о токенах доступа текущего пользователя
+// Связывание нового идентификатора с аккаунтом
-router.get('/tokens', requireAuth, async (req, res) => {
+router.post('/link-identity', requireAuth, async (req, res) => {
   try {
-    // Логирование для отладки
+    const { identityType, identityValue } = req.body;
-    console.log('GET /api/access/tokens запрос получен');
-    console.log('Сессия пользователя:', req.session);
     
-    // Получаем адрес из сессии, а не из заголовков
+    if (!identityType || !identityValue) {
-    if (!req.session || !req.session.address) {
+      return res.status(400).json({ error: 'Отсутствуют обязательные поля' });
-      return res.status(400).json({ error: 'No wallet address in session' });
     }
     
-    const address = req.session.address.toLowerCase();
+    // Проверяем, не привязан ли уже этот идентификатор к другому пользователю
+    const existingUserId = await authService.getUserIdByIdentity(identityType, identityValue);
     
-    // Используем правильное имя таблицы и полей
+    if (existingUserId && existingUserId !== req.user.id) {
-    const result = await db.query(
+      return res.status(400).json({ error: 'Этот идентификатор уже привязан к другому аккаунту' });
-      'SELECT id, wallet_address, role, created_at, expires_at FROM access_tokens WHERE LOWER(wallet_address) = $1',
-      [address]
-    );
-
-    return res.json(result.rows);
-  } catch (error) {
-    console.error('Ошибка при получении токенов:', error);
-    res.status(500).json({ error: 'Ошибка сервера' });
-  }
-});
-
-router.post('/mint', requireAuth, requireAdmin, async (req, res) => {
-  try {
-    // Логирование для отладки
-    console.log('POST /api/access/mint запрос получен');
-    console.log('Данные запроса:', req.body);
-
-    const { walletAddress, role, expiresInDays } = req.body;
-
-    if (!walletAddress || !role || !expiresInDays) {
-      return res.status(400).json({ error: 'Missing required fields' });
     }
     
-    // Вычисляем дату истечения
+    // Добавляем новый идентификатор
-    const expiresAt = new Date();
+    if (!existingUserId) {
-    expiresAt.setDate(expiresAt.getDate() + parseInt(expiresInDays));
+      await db.query(
+        'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
+        [req.user.id, identityType, identityValue]
+      );
+    }
     
-    // Создаем токен
+    // Если добавлен кошелек, проверяем токены
-    const result = await pool.query(
+    if (identityType === 'wallet') {
-      'INSERT INTO access_tokens (wallet_address, role, expires_at) VALUES ($1, $2, $3) RETURNING *',
+      await authService.checkTokensAndUpdateRole(identityValue);
-      [walletAddress.toLowerCase(), role, expiresAt]
+    }
-    );
+    
+    // Получаем все идентификаторы пользователя
+    const identities = await authService.getAllUserIdentities(req.user.id);
+    
+    // Получаем текущую роль
+    const isAdmin = await authService.isAdmin(req.user.id);
     
     res.json({
-      id: result.rows[0].id,
+      success: true,
-      walletAddress: result.rows[0].wallet_address,
+      identities,
-      role: result.rows[0].role,
+      isAdmin
-      createdAt: result.rows[0].created_at,
-      expiresAt: result.rows[0].expires_at,
     });
   } catch (error) {
-    console.error('Ошибка при создании токена:', error);
+    logger.error(`Link identity error: ${error.message}`);
     res.status(500).json({ error: 'Ошибка сервера' });
   }
 });

backend/routes/admin.js

@@ -1,79 +1,7 @@
 const express = require('express');
 const router = express.Router();
 const db = require('../db');
-const { checkIfAdmin } = require('../utils/access-check');
+const { requireAdmin } = require('../middleware/auth');
-
-// Middleware для проверки прав администратора
-const requireAdmin = async (req, res, next) => {
-  console.log('Проверка прав администратора:', {
-    session: req.session
-      ? {
-          authenticated: req.session.authenticated,
-          address: req.session.address,
-          isAdmin: req.session.isAdmin,
-        }
-      : null,
-    headers: {
-      authorization: req.headers.authorization,
-    },
-  });
-
-  // Проверка аутентификации через сессию
-  if (req.session && req.session.authenticated && req.session.isAdmin) {
-    console.log('Пользователь авторизован как администратор через сессию');
-    return next();
-  }
-
-  // Проверка через заголовок авторизации
-  const authHeader = req.headers.authorization;
-  if (!authHeader || !authHeader.startsWith('Bearer ')) {
-    console.log('Отсутствует заголовок авторизации');
-    return res.status(401).json({ error: 'Unauthorized' });
-  }
-
-  const address = authHeader.split(' ')[1];
-  console.log('Проверка адреса из заголовка:', address);
-
-  try {
-    // Проверяем напрямую в базе данных
-    const userResult = await db.query('SELECT is_admin FROM users WHERE address = $1', [
-      address.toLowerCase(),
-    ]);
-
-    if (userResult.rows.length === 0) {
-      console.log(`Пользователь с адресом ${address} не найден`);
-      return res.status(404).json({ error: 'User not found' });
-    }
-
-    const isAdmin = userResult.rows[0].is_admin;
-    console.log(`Пользователь с адресом ${address} имеет статус администратора:`, isAdmin);
-
-    if (!isAdmin) {
-      console.log(`Пользователь с адресом ${address} не является администратором`);
-      return res.status(403).json({ error: 'Forbidden' });
-    }
-
-    // Обновляем сессию
-    if (req.session) {
-      req.session.authenticated = true;
-      req.session.address = address;
-      req.session.isAdmin = true;
-
-      console.log('Сессия обновлена из middleware:', {
-        address,
-        isAdmin: true,
-      });
-    }
-
-    next();
-  } catch (error) {
-    console.error('Ошибка при проверке прав администратора:', error);
-    return res.status(500).json({ error: 'Internal server error' });
-  }
-};
-
-// Применяем middleware ко всем маршрутам
-router.use(requireAdmin);
 
 // Маршрут для получения списка пользователей
 router.get('/users', async (req, res) => {
@@ -86,8 +14,8 @@ router.get('/users', async (req, res) => {
   }
 });
 
-// Маршрут для получения статистики
+// Маршрут для получения статистики (защищен middleware requireAdmin)
-router.get('/stats', async (req, res) => {
+router.get('/stats', requireAdmin, async (req, res) => {
   try {
     // Получаем количество пользователей
     const usersCount = await db.query('SELECT COUNT(*) FROM users');

backend/routes/auth.js

@@ -6,10 +6,10 @@ const db = require('../db');
 const logger = require('../utils/logger');
 const helmet = require('helmet');
 const rateLimit = require('express-rate-limit');
-const { checkIfAdmin } = require('../utils/access-check');
 const { checkRole, requireAuth } = require('../middleware/auth');
 const { pool } = require('../db');
 const { verifySignature, checkAccess, findOrCreateUser } = require('../utils/auth');
+const authService = require('../services/auth-service');
 
 // Создайте лимитер для попыток аутентификации
 const authLimiter = rateLimit({
@@ -24,39 +24,31 @@ const authLimiter = rateLimit({
 router.get('/nonce', async (req, res) => {
   try {
     const { address } = req.query;
-
     if (!address) {
       return res.status(400).json({ error: 'Address is required' });
     }
 
-    // Генерируем nonce
+    // Генерируем случайный nonce
     const nonce = crypto.randomBytes(16).toString('hex');
     
     // Сохраняем nonce в сессии
     req.session.authNonce = nonce;
-    req.session.pendingAddress = address.toLowerCase();
+    req.session.pendingAddress = address;
     
-    console.log('Сгенерирован nonce для адреса:', address);
+    // Важно: сохраняем сессию перед отправкой ответа
-    console.log('Сессия после генерации nonce:', req.session);
-
-    // Сохраняем сессию и ждем завершения
     await new Promise((resolve, reject) => {
-      req.session.save((err) => {
+      req.session.save(err => {
-        if (err) {
+        if (err) reject(err);
-          console.error('Ошибка при сохранении сессии:', err);
+        else resolve();
-          reject(err);
-        } else {
-          resolve();
-        }
       });
     });
     
-    // Проверяем, что nonce сохранился
+    console.log('Сессия после генерации nonce:', req.session);
     console.log('Сессия после сохранения:', req.session);
     
     return res.json({ nonce });
   } catch (error) {
-    console.error('Ошибка при генерации nonce:', error);
+    console.error('Error generating nonce:', error);
     return res.status(500).json({ error: 'Internal server error' });
   }
 });
@@ -89,135 +81,227 @@ async function checkUserRole(address, req) {
   }
 }
 
-// Верификация подписи
+// Проверка подписи и аутентификация
 router.post('/verify', async (req, res) => {
   try {
-    const { address, signature, message, nonce } = req.body;
+    const { address, signature, message } = req.body;
     
-    console.log('Верификация подписи:', { address, signature, message });
+    console.log('Verify request: address=' + address + ', signature=' + signature.substring(0, 10) + '...');
-    console.log('Сессия при верификации:', req.session);
+    console.log('Session data: nonce=' + req.session.authNonce + ', pendingAddress=' + req.session.pendingAddress);
     
-    if (!address || !signature || !message) {
+    // Проверяем, что nonce и адрес совпадают с сохраненными в сессии
-      return res.status(400).json({ error: 'Address, signature and message are required' });
+    if (!req.session.authNonce || !req.session.pendingAddress || req.session.pendingAddress !== address) {
+      console.error(`Invalid session or address mismatch: nonce=${req.session.authNonce}, pendingAddress=${req.session.pendingAddress}, address=${address}`);
+      return res.status(401).json({ error: 'Invalid session or address mismatch' });
     }
     
-    // Проверяем наличие nonce в сессии
+    // Проверяем подпись
-    if (!req.session.authNonce || !req.session.pendingAddress) {
+    const isValid = await verifySignature(req.session.authNonce, signature, address);
-      console.error('Сессия не содержит nonce или pendingAddress:', req.session);
+    console.log('Signature verification result:', isValid);
     
-      // Проверяем наличие nonce в заголовке
+    if (!isValid) {
-      const headerNonce = req.headers['x-auth-nonce'];
+      return res.status(401).json({ error: 'Invalid signature' });
-      if (headerNonce) {
+    }
-        console.log('Найден nonce в заголовке:', headerNonce);
-        req.session.authNonce = headerNonce;
-        req.session.pendingAddress = address.toLowerCase();
-      }
     
-      // Если в запросе есть nonce в сообщении, извлекаем его
+    // Находим или создаем пользователя
-      let extractedNonce = null;
+    console.log('Finding or creating user for address:', address);
-      if (message) {
+    const { userId, isAdmin } = await findOrCreateUser(address);
-        const match = message.match(/nonce: ([a-f0-9]+)/);
+    console.log('User found/created:', { userId, isAdmin });
-        if (match && match[1]) {
-          extractedNonce = match[1];
-          console.log('Извлечен nonce из сообщения:', extractedNonce);
     
-          // Устанавливаем nonce в сессию
+    // Очищаем nonce и pendingAddress из сессии
-          req.session.authNonce = extractedNonce;
+    const nonce = req.session.authNonce;
-          req.session.pendingAddress = address.toLowerCase();
+    req.session.authNonce = null;
+    req.session.pendingAddress = null;
     
-          // Сохраняем сессию
+    // Устанавливаем пользователя в сессии
-          await new Promise((resolve) => {
+    req.session.userId = userId;
-            req.session.save((err) => {
+    req.session.address = address;
-              if (err) console.error('Ошибка при сохранении сессии:', err);
+    req.session.isAdmin = isAdmin;
-              resolve();
+    req.session.authenticated = true;
-            });
+    
-          });
+    // Сохраняем сессию
+    await new Promise((resolve, reject) => {
+      req.session.save(err => {
+        if (err) {
+          console.error('Error saving session:', err);
+          reject(err);
+        } else {
+          console.log('Session saved successfully');
+          resolve();
         }
-      }
+      });
+    });
+    
+    console.log('Authentication successful for user:', { userId, address, isAdmin });
+    
+    return res.json({
+      authenticated: true,
+      userId,
+      address,
+      isAdmin,
+      authType: 'wallet'
+    });
+  } catch (error) {
+    console.error('Error verifying signature:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Аутентификация через Telegram
+router.post('/telegram', async (req, res) => {
+  try {
+    const { telegramId, authData } = req.body;
+    
+    // Здесь должна быть проверка данных от Telegram
+    
+    // Получаем или создаем пользователя
+    let userId = await authService.getUserIdByIdentity('telegram', telegramId);
+    
+    if (!userId) {
+      // Создаем нового пользователя
+      const userResult = await db.query(
+        'INSERT INTO users (created_at, role_id) VALUES (NOW(), (SELECT id FROM roles WHERE name = $1)) RETURNING id',
+        ['user']
+      );
+      
+      userId = userResult.rows[0].id;
+      
+      // Добавляем идентификатор Telegram
+      await db.query(
+        'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
+        [userId, 'telegram', telegramId]
+      );
     }
     
-    // Формируем ожидаемое сообщение
+    // Проверяем связанные аккаунты
-    const expectedMessage = `Подтвердите вход в DApp for Business с nonce: ${req.session.authNonce}`;
+    const identities = await authService.getAllUserIdentities(userId);
     
-    // Проверяем, что адрес совпадает с ожидаемым
+    // Если есть связанный кошелек, проверяем токены
-    if (req.session.pendingAddress && req.session.pendingAddress.toLowerCase() !== address.toLowerCase()) {
+    if (identities.wallet) {
-      console.error('Адрес не совпадает с ожидаемым:', {
+      await authService.checkTokensAndUpdateRole(identities.wallet);
-        expected: req.session.pendingAddress,
-        received: address,
-      });
-      return res.status(400).json({ error: 'Invalid address' });
     }
     
-    let verified = false;
+    // Получаем текущую роль
-    try {
+    const isAdmin = await authService.isAdmin(userId);
-      // Проверяем подпись с использованием ethers.js
-      const recoveredAddress = ethers.verifyMessage(expectedMessage, signature);
     
-      if (recoveredAddress.toLowerCase() !== address.toLowerCase()) {
+    // Устанавливаем сессию
-        console.error('Неверная подпись:', {
+    req.session.userId = userId;
-          expected: address.toLowerCase(),
+    req.session.telegramId = telegramId;
-          recovered: recoveredAddress.toLowerCase(),
+    req.session.authType = 'telegram';
-        });
+    req.session.authenticated = true;
-        return res.status(400).json({ error: 'Invalid signature' });
-      }
     
-      verified = true;
+    res.json({
-      console.log('Подпись успешно проверена');
+      authenticated: true,
-    } catch (error) {
+      userId,
-      console.error('Ошибка при проверке подписи:', error);
+      isAdmin,
-      return res.status(400).json({ error: 'Invalid signature format' });
+      authType: 'telegram',
+      identities
+    });
+  } catch (error) {
+    logger.error(`Telegram auth error: ${error.message}`);
+    res.status(500).json({ error: 'Ошибка сервера' });
+  }
+});
+
+// Аутентификация через Email
+router.post('/email', async (req, res) => {
+  try {
+    const { email, verificationCode } = req.body;
+    
+    // Здесь должна быть проверка кода подтверждения
+    
+    // Получаем или создаем пользователя
+    let userId = await authService.getUserIdByIdentity('email', email);
+    
+    if (!userId) {
+      // Создаем нового пользователя
+      const userResult = await db.query(
+        'INSERT INTO users (created_at, role_id) VALUES (NOW(), (SELECT id FROM roles WHERE name = $1)) RETURNING id',
+        ['user']
+      );
+      
+      userId = userResult.rows[0].id;
+      
+      // Добавляем идентификатор Email
+      await db.query(
+        'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
+        [userId, 'email', email]
+      );
     }
     
-    // Если подпись верна, аутентифицируем пользователя
+    // Проверяем связанные аккаунты
-    if (verified) {
+    const identities = await authService.getAllUserIdentities(userId);
-      // Найдем или создадим пользователя
-      const user = await findOrCreateUser(address, 'wallet');
     
-      // Обновляем сессию
+    // Если есть связанный кошелек, проверяем токены
-      req.session.authenticated = true;
+    if (identities.wallet) {
-      req.session.address = address;
+      await authService.checkTokensAndUpdateRole(identities.wallet);
-      req.session.userId = user.id;
+    }
-      req.session.authType = 'wallet';
-      req.session.isAdmin = user.is_admin;
-      req.session.role = user.role;
-      req.session.authChannel = 'web';
-      req.session.language = req.body.language || 'en';
     
-      // Удаляем временные данные
+    // Получаем текущую роль
-      delete req.session.authNonce;
+    const isAdmin = await authService.isAdmin(userId);
-      delete req.session.pendingAddress;
     
-      // Сохраняем сессию
+    // Устанавливаем сессию
-      await new Promise((resolve, reject) => {
+    req.session.userId = userId;
-        req.session.save(err => {
+    req.session.email = email;
-          if (err) {
+    req.session.authType = 'email';
-            console.error('Ошибка при сохранении сессии:', err);
+    req.session.authenticated = true;
-            reject(err);
-          } else {
-            resolve();
-          }
-        });
-      });
-      
-      console.log('Аутентификация успешна:', { 
-        address, 
-        isAdmin: user.is_admin,
-        userId: user.id,
-        role: user.role
-      });
       
       res.json({ 
         authenticated: true, 
-        address, 
+      userId,
-        isAdmin: user.is_admin,
+      isAdmin,
-        role: user.role
+      authType: 'email',
-      });
+      identities
-    } else {
+    });
-      res.status(401).json({ error: 'Invalid signature' });
-    }
   } catch (error) {
-    console.error('Authentication error:', error);
+    logger.error(`Email auth error: ${error.message}`);
-    res.status(500).json({ error: 'Internal server error' });
+    res.status(500).json({ error: 'Ошибка сервера' });
+  }
+});
+
+// Связывание аккаунтов
+router.post('/link-identity', async (req, res) => {
+  try {
+    if (!req.session || !req.session.userId) {
+      return res.status(401).json({ error: 'Требуется аутентификация' });
+    }
+    
+    const { identityType, identityValue } = req.body;
+    
+    // Проверяем, не привязан ли уже этот идентификатор к другому пользователю
+    const existingUserId = await authService.getUserIdByIdentity(identityType, identityValue);
+    
+    if (existingUserId && existingUserId !== req.session.userId) {
+      return res.status(400).json({ error: 'Этот идентификатор уже привязан к другому аккаунту' });
+    }
+    
+    // Добавляем новый идентификатор
+    if (!existingUserId) {
+      await db.query(
+        'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
+        [req.session.userId, identityType, identityValue]
+      );
+    }
+    
+    // Если добавлен кошелек, проверяем токены
+    if (identityType === 'wallet') {
+      await authService.checkTokensAndUpdateRole(identityValue);
+    }
+    
+    // Получаем все идентификаторы пользователя
+    const identities = await authService.getAllUserIdentities(req.session.userId);
+    
+    // Получаем текущую роль
+    const isAdmin = await authService.isAdmin(req.session.userId);
+    
+    res.json({
+      success: true,
+      identities,
+      isAdmin
+    });
+  } catch (error) {
+    logger.error(`Link identity error: ${error.message}`);
+    res.status(500).json({ error: 'Ошибка сервера' });
   }
 });
 
@@ -418,76 +502,42 @@ router.get('/check-access', requireAuth, (req, res) => {
   }
 });
 
-// Упрощенный маршрут для обновления сессии
+// Добавьте этот маршрут в routes/auth.js
 router.post('/refresh-session', async (req, res) => {
   try {
     const { address } = req.body;
     
     if (!address) {
-      return res.status(400).json({ success: false, message: 'Адрес не указан' });
+      return res.status(400).json({ error: 'Address is required' });
     }
     
-    console.log(`Получен запрос на обновление сессии для адреса: ${address}`);
+    logger.info(`Получен запрос на обновление сессии для адреса: ${address}`);
     
-    // Проверяем, существует ли пользователь в базе данных
+    // Проверяем доступ пользователя
-    const userResult = await pool.query('SELECT * FROM users WHERE address = $1', [
+    const accessInfo = await checkAccess(address);
-      address.toLowerCase(),
-    ]);
     
-    let user = null;
+    if (!accessInfo.hasAccess) {
-
+      return res.status(401).json({ error: 'Unauthorized' });
-    if (userResult.rows.length > 0) {
-      user = userResult.rows[0];
-      console.log(`Найден пользователь: ${user.id}`);
-    } else {
-      console.log(`Пользователь с адресом ${address} не найден`);
     }
     
-    // Обновляем сессию
+    // Устанавливаем данные сессии
     req.session.authenticated = true;
-    req.session.address = address.toLowerCase();
+    req.session.address = address;
+    req.session.userId = accessInfo.userId;
+    req.session.isAdmin = accessInfo.isAdmin;
+    req.session.authType = 'wallet';
     
-    if (user) {
+    await req.session.save();
-      req.session.userId = user.id;
-      req.session.isAdmin = user.is_admin || false;
-      req.session.role = user.is_admin ? 'ADMIN' : 'USER';
-    } else {
-      // Если пользователь не найден в базе, проверяем через переменные окружения
-      const adminAddresses = (process.env.ADMIN_ADDRESSES || '')
-        .split(',')
-        .map((a) => a.toLowerCase());
-      const isAdmin = adminAddresses.includes(address.toLowerCase());
-      req.session.isAdmin = isAdmin;
-      req.session.role = isAdmin ? 'ADMIN' : 'USER';
-    }
     
-    // Сохраняем сессию
+    res.json({
-    await new Promise((resolve, reject) => {
+      authenticated: true,
-      req.session.save((err) => {
+      address,
-        if (err) {
+      isAdmin: accessInfo.isAdmin,
-          console.error('Ошибка при сохранении сессии:', err);
+      authType: 'wallet'
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
-    });
-
-    console.log('Сессия обновлена:', req.session);
-
-    return res.json({
-      success: true,
-      message: 'Сессия обновлена',
-      user: {
-        id: user ? user.id : null,
-        address: address.toLowerCase(),
-        isAdmin: req.session.isAdmin,
-        role: req.session.role,
-      },
     });
   } catch (error) {
-    console.error('Ошибка при обновлении сессии:', error);
+    logger.error(`Error refreshing session: ${error.message}`);
-    return res.status(500).json({ success: false, message: 'Ошибка сервера' });
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
@@ -555,10 +605,56 @@ router.get('/check-db-structure', async (req, res) => {
   }
 });
 
+// Добавьте этот маршрут для отладки
+router.get('/debug-session', (req, res) => {
+  res.json({
+    sessionID: req.sessionID,
+    session: req.session,
+    authenticated: req.session ? req.session.authenticated : undefined,
+    address: req.session ? req.session.address : undefined,
+    userId: req.session ? req.session.userId : undefined,
+    isAdmin: req.session ? req.session.isAdmin : undefined,
+    role: req.session ? req.session.role : undefined
+  });
+});
+
+// Маршрут для проверки сессии
+router.get('/session-debug', (req, res) => {
+  console.log('Текущая сессия:', {
+    id: req.sessionID,
+    session: req.session,
+    cookie: req.session.cookie
+  });
+  
+  res.json({
+    sessionID: req.sessionID,
+    authenticated: req.session.authenticated,
+    address: req.session.address,
+    userId: req.session.userId,
+    isAdmin: req.session.isAdmin,
+    role: req.session.role,
+    cookie: req.session.cookie
+  });
+});
+
+// Маршрут для проверки содержимого таблицы сессий
+router.get('/check-sessions', async (req, res) => {
+  try {
+    const result = await pool.query('SELECT * FROM sessions');
+    res.json({
+      currentSessionID: req.sessionID,
+      sessions: result.rows
+    });
+  } catch (error) {
+    console.error('Ошибка при получении сессий:', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
 // Добавьте обработку ошибок
 router.use((err, req, res, next) => {
   console.error('Auth route error:', err);
   res.status(500).json({ success: false, message: 'Ошибка сервера' });
 });
 
-module.exports = { router };
+module.exports = router;

backend/routes/chat.js

@@ -8,14 +8,12 @@ const logger = require('../utils/logger');
 
 // Обработчик сообщений чата
 router.post('/message', requireAuth, async (req, res) => {
+  console.log('Сессия в /api/chat/message:', req.session);
+  console.log('Аутентифицирован:', req.session.authenticated);
+  
   try {
     const { message, language = 'ru' } = req.body;
     
-    // Проверка аутентификации
-    if (!req.session || !req.session.authenticated) {
-      return res.status(401).json({ error: 'Требуется аутентификация' });
-    }
-    
     console.log(`Получено сообщение: ${message}, язык: ${language}`);
 
     // Определяем язык сообщения, если не указан явно
@@ -175,26 +173,4 @@ router.get('/admin/history', requireAdmin, async (req, res) => {
   }
 });
 
-// Сохранение сообщения в историю чата
-router.post('/message', requireAuth, async (req, res) => {
-  try {
-    const { content, channel = 'web', metadata = {} } = req.body;
-    const userId = req.session.userId;
-    
-    // Сохранение сообщения пользователя
-    const userMessageResult = await db.query(`
-      INSERT INTO chat_history (user_id, channel, sender_type, content, metadata)
-      VALUES ($1, $2, 'user', $3, $4)
-      RETURNING id
-    `, [userId, channel, content, metadata]);
-    
-    const messageId = userMessageResult.rows[0].id;
-    
-    res.json({ success: true, messageId });
-  } catch (error) {
-    logger.error('Error saving chat message:', error);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
-  }
-});
-
 module.exports = router;

backend/routes/conversations.js

@@ -0,0 +1 @@
+

backend/routes/identities.js

@@ -1,27 +1,14 @@
 const express = require('express');
 const router = express.Router();
 const { linkIdentity, getUserIdentities } = require('../utils/identity-linker');
-const { Pool } = require('pg');
+const db = require('../db');
-
+const { requireAuth } = require('../middleware/auth');
-// Подключение к БД
-const pool = new Pool({
-  connectionString: process.env.DATABASE_URL,
-  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
-});
-
-// Middleware для проверки аутентификации
-function requireAuth(req, res, next) {
-  if (!req.session || (!req.session.isAuthenticated && !req.session.authenticated)) {
-    return res.status(401).json({ error: 'Unauthorized' });
-  }
-  next();
-}
 
 // Получение связанных идентификаторов пользователя
 router.get('/', requireAuth, async (req, res) => {
   try {
     // Получаем ID пользователя по Ethereum-адресу
-    const result = await pool.query('SELECT id FROM users WHERE address = $1', [
+    const result = await db.query('SELECT id FROM users WHERE address = $1', [
       req.session.address,
     ]);
 
@@ -47,7 +34,7 @@ router.delete('/:type/:value', requireAuth, async (req, res) => {
     const { type, value } = req.params;
 
     // Получаем ID пользователя по Ethereum-адресу
-    const result = await pool.query('SELECT id FROM users WHERE address = $1', [
+    const result = await db.query('SELECT id FROM users WHERE address = $1', [
       req.session.address,
     ]);
 
@@ -58,7 +45,7 @@ router.delete('/:type/:value', requireAuth, async (req, res) => {
     const userId = result.rows[0].id;
 
     // Удаляем идентификатор
-    await pool.query(
+    await db.query(
       'DELETE FROM user_identities WHERE user_id = $1 AND identity_type = $2 AND identity_value = $3',
       [userId, type, value]
     );

backend/routes/roles.js

@@ -2,54 +2,164 @@ const express = require('express');
 const router = express.Router();
 const db = require('../db');
 const { requireAuth, requireAdmin } = require('../middleware/auth');
-const { checkTokenBalanceAndUpdateRole } = require('../utils/access-check');
+const authService = require('../services/auth-service');
 const logger = require('../utils/logger');
+const { USER_ROLES } = require('../utils/constants');
 
-// Маршрут для проверки и обновления роли пользователя
+// Получение всех ролей
-router.post('/check-role', requireAuth, async (req, res) => {
+router.get('/', async (req, res) => {
-  try {
-    if (!req.session.address) {
-      return res.status(400).json({ error: 'В сессии отсутствует адрес кошелька' });
-    }
-    
-    const isAdmin = await checkTokenBalanceAndUpdateRole(req.session.address);
-    
-    // Обновление сессии
-    req.session.isAdmin = isAdmin;
-    
-    res.json({ isAdmin });
-  } catch (error) {
-    logger.error('Error checking role:', error);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
-  }
-});
-
-// Маршрут для получения всех ролей (только для админов)
-router.get('/', requireAdmin, async (req, res) => {
   try {
     const result = await db.query('SELECT * FROM roles ORDER BY id');
     res.json(result.rows);
   } catch (error) {
-    logger.error('Error fetching roles:', error);
+    logger.error(`Error getting roles: ${error.message}`);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
-// Маршрут для получения пользователей с их ролями (только для админов)
+// Получение роли текущего пользователя
-router.get('/users', requireAdmin, async (req, res) => {
+router.get('/me', requireAuth, async (req, res) => {
   try {
-    const result = await db.query(`
+    const userId = req.session.userId;
-      SELECT u.id, u.username, u.preferred_language, r.name as role, 
-             u.created_at, u.last_token_check
-      FROM users u
-      LEFT JOIN roles r ON u.role_id = r.id
-      ORDER BY u.created_at DESC
-    `);
     
-    res.json(result.rows);
+    const result = await db.query(`
+      SELECT r.name as role
+      FROM users u
+      JOIN roles r ON u.role_id = r.id
+      WHERE u.id = $1
+    `, [userId]);
+    
+    if (result.rows.length === 0) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    
+    res.json({ role: result.rows[0].role });
   } catch (error) {
-    logger.error('Error fetching users with roles:', error);
+    logger.error(`Error getting user role: ${error.message}`);
-    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Создание новой роли (только для администраторов)
+router.post('/', requireAuth, requireAdmin, async (req, res) => {
+  try {
+    const { name, description } = req.body;
+    
+    if (!name) {
+      return res.status(400).json({ error: 'Role name is required' });
+    }
+    
+    // Проверяем, существует ли уже такая роль
+    const existingRole = await db.query('SELECT * FROM roles WHERE name = $1', [name]);
+    
+    if (existingRole.rows.length > 0) {
+      return res.status(400).json({ error: 'Role already exists' });
+    }
+    
+    // Создаем новую роль
+    const result = await db.query(
+      'INSERT INTO roles (name, description) VALUES ($1, $2) RETURNING *',
+      [name, description || '']
+    );
+    
+    res.status(201).json(result.rows[0]);
+  } catch (error) {
+    logger.error(`Error creating role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Обновление роли (только для администраторов)
+router.put('/:id', requireAuth, requireAdmin, async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { name, description } = req.body;
+    
+    if (!name) {
+      return res.status(400).json({ error: 'Role name is required' });
+    }
+    
+    // Проверяем, существует ли роль
+    const existingRole = await db.query('SELECT * FROM roles WHERE id = $1', [id]);
+    
+    if (existingRole.rows.length === 0) {
+      return res.status(404).json({ error: 'Role not found' });
+    }
+    
+    // Обновляем роль
+    const result = await db.query(
+      'UPDATE roles SET name = $1, description = $2 WHERE id = $3 RETURNING *',
+      [name, description || '', id]
+    );
+    
+    res.json(result.rows[0]);
+  } catch (error) {
+    logger.error(`Error updating role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Удаление роли (только для администраторов)
+router.delete('/:id', requireAuth, requireAdmin, async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    // Проверяем, существует ли роль
+    const existingRole = await db.query('SELECT * FROM roles WHERE id = $1', [id]);
+    
+    if (existingRole.rows.length === 0) {
+      return res.status(404).json({ error: 'Role not found' });
+    }
+    
+    // Проверяем, не используется ли роль
+    const usersWithRole = await db.query('SELECT COUNT(*) FROM users WHERE role_id = $1', [id]);
+    
+    if (parseInt(usersWithRole.rows[0].count) > 0) {
+      return res.status(400).json({ error: 'Cannot delete role that is assigned to users' });
+    }
+    
+    // Удаляем роль
+    await db.query('DELETE FROM roles WHERE id = $1', [id]);
+    
+    res.json({ success: true });
+  } catch (error) {
+    logger.error(`Error deleting role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Назначение роли пользователю (только для администраторов)
+router.post('/assign', requireAuth, requireAdmin, async (req, res) => {
+  try {
+    const { userId, roleName } = req.body;
+    
+    if (!userId || !roleName) {
+      return res.status(400).json({ error: 'User ID and role name are required' });
+    }
+    
+    // Проверяем, существует ли роль
+    const roleResult = await db.query('SELECT id FROM roles WHERE name = $1', [roleName]);
+    
+    if (roleResult.rows.length === 0) {
+      return res.status(404).json({ error: 'Role not found' });
+    }
+    
+    const roleId = roleResult.rows[0].id;
+    
+    // Проверяем, существует ли пользователь
+    const userResult = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
+    
+    if (userResult.rows.length === 0) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    
+    // Назначаем роль
+    await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [roleId, userId]);
+    
+    res.json({ success: true });
+  } catch (error) {
+    logger.error(`Error assigning role: ${error.message}`);
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 

backend/scripts/check-state.js

@@ -1,34 +1,37 @@
-const hre = require('hardhat');
+const { getContract } = require('../utils/contracts');
+const logger = require('../utils/logger');
 
 async function main() {
-  const accessToken = await hre.ethers.getContractAt(
+  try {
-    'AccessToken',
+    const accessToken = await getContract('AccessToken');
-    '0xF352c498cF0857F472dC473E4Dd39551E79B1063'
-  );
 
-  const owner = await accessToken.owner();
+    const owner = await accessToken.owner();
-  console.log('Contract owner:', owner);
+    logger.info('Contract owner:', owner);
 
-  // Проверяем все токены и их владельцев
+    // Проверяем все токены и их владельцев
-  console.log('\nAll tokens:');
+    logger.info('\nAll tokens:');
-  for (let i = 1; i <= 10; i++) {
+    for (let i = 1; i <= 10; i++) {
-    try {
+      try {
-      const tokenOwner = await accessToken.ownerOf(i);
+        const tokenOwner = await accessToken.ownerOf(i);
-      console.log(`Token ${i} owner: ${tokenOwner}`);
+        logger.info(`Token ${i} owner: ${tokenOwner}`);
-    } catch (error) {
+      } catch (error) {
-      if (!error.message.includes('invalid token ID')) {
+        if (!error.message.includes('invalid token ID')) {
-        console.log(`Token ${i} error:`, error.message);
+          logger.error(`Token ${i} error:`, error.message);
+        }
       }
     }
-  }
 
-  // Проверяем активные токены для всех известных адресов
+    // Проверяем активные токены для всех известных адресов
-  const addresses = [owner, '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'];
+    const addresses = [owner, '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'];
 
-  console.log('\nActive tokens:');
+    logger.info('\nActive tokens:');
-  for (const address of addresses) {
+    for (const address of addresses) {
-    const activeToken = await accessToken.activeTokens(address);
+      const activeToken = await accessToken.activeTokens(address);
-    console.log(`${address}: Token ${activeToken.toString()}`);
+      logger.info(`${address}: Token ${activeToken.toString()}`);
+    }
+  } catch (error) {
+    logger.error(error);
+    process.exit(1);
   }
 }
 

backend/scripts/create-moderator.js

@@ -1,50 +0,0 @@
-const hre = require('hardhat');
-
-async function main() {
-  const accessToken = await hre.ethers.getContractAt(
-    'AccessToken',
-    '0xF352c498cF0857F472dC473E4Dd39551E79B1063'
-  );
-
-  const moderatorAddress = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8';
-
-  try {
-    console.log('\nMinting moderator token...');
-    const mintTx = await accessToken.mintAccessToken(moderatorAddress, 1); // MODERATOR
-    console.log('Waiting for transaction:', mintTx.hash);
-    await mintTx.wait();
-    console.log('Moderator token minted');
-
-    // Проверяем результат
-    const activeToken = await accessToken.activeTokens(moderatorAddress);
-    console.log(`Moderator's active token: ${activeToken}`);
-
-    const role = await accessToken.checkRole(moderatorAddress);
-    console.log(`Moderator role: ${['ADMIN', 'MODERATOR', 'SUPPORT'][role]}`);
-  } catch (error) {
-    console.log('Moderator token minting error:', error.message);
-  }
-
-  // Проверяем все активные токены
-  console.log('\nAll active tokens:');
-  const addresses = [await accessToken.owner(), moderatorAddress];
-
-  for (const address of addresses) {
-    try {
-      const activeToken = await accessToken.activeTokens(address);
-      const role = await accessToken.checkRole(address);
-      console.log(
-        `${address}: Token ${activeToken}, Role: ${['ADMIN', 'MODERATOR', 'SUPPORT'][role]}`
-      );
-    } catch (error) {
-      console.log(`${address}: ${error.message}`);
-    }
-  }
-}
-
-main()
-  .then(() => process.exit(0))
-  .catch((error) => {
-    console.error('Script error:', error);
-    process.exit(1);
-  });

backend/scripts/deploy-access.js

@@ -1,23 +1,29 @@
 const hre = require('hardhat');
+const logger = require('../utils/logger');
 
 async function main() {
-  const AccessToken = await hre.ethers.getContractFactory('AccessToken');
+  try {
-  const accessToken = await AccessToken.deploy();
+    const AccessToken = await hre.ethers.getContractFactory('AccessToken');
-  await accessToken.waitForDeployment();
+    const accessToken = await AccessToken.deploy();
+    await accessToken.waitForDeployment();
 
-  const address = await accessToken.getAddress();
+    const address = await accessToken.getAddress();
-  console.log('AccessToken deployed to:', address);
+    logger.info('AccessToken deployed to:', address);
 
-  // Создаем первый админский токен для владельца контракта
+    // Создаем первый админский токен для владельца контракта
-  const [owner] = await hre.ethers.getSigners();
+    const [owner] = await hre.ethers.getSigners();
-  const tx = await accessToken.mintAccessToken(owner.address, 0); // 0 = ADMIN
+    const tx = await accessToken.mintAccessToken(owner.address, 1); // 1 = ADMIN
-  await tx.wait();
+    await tx.wait();
-  console.log('Admin token minted for:', owner.address);
+    logger.info('Admin token minted for:', owner.address);
+  } catch (error) {
+    logger.error('Deployment error:', error);
+    process.exit(1);
+  }
 }
 
 main()
   .then(() => process.exit(0))
   .catch((error) => {
-    console.error(error);
+    logger.error('Unhandled error:', error);
     process.exit(1);
   });

backend/scripts/init-db.js

@@ -1,65 +0,0 @@
-const { Pool } = require('pg');
-const dotenv = require('dotenv');
-
-dotenv.config();
-
-const pool = new Pool({
-  connectionString: process.env.DATABASE_URL,
-  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
-});
-
-async function initDb() {
-  try {
-    console.log('Инициализация базы данных...');
-
-    // Добавляем тестового пользователя
-    await pool.query(`
-      INSERT INTO users (address, is_admin)
-      VALUES ('0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b', TRUE)
-      ON CONFLICT (address) DO NOTHING
-    `);
-
-    // Добавляем тестовую доску
-    await pool.query(`
-      INSERT INTO kanban_boards (title, description, owner_id, is_public)
-      VALUES (
-        'Тестовая доска', 
-        'Описание тестовой доски', 
-        (SELECT id FROM users WHERE address = '0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b'), 
-        TRUE
-      )
-      ON CONFLICT DO NOTHING
-    `);
-
-    // Получаем ID доски
-    const boardResult = await pool.query(`
-      SELECT id FROM kanban_boards WHERE title = 'Тестовая доска' LIMIT 1
-    `);
-
-    if (boardResult.rows.length > 0) {
-      const boardId = boardResult.rows[0].id;
-
-      // Добавляем тестовые колонки
-      await pool.query(
-        `
-        INSERT INTO kanban_columns (board_id, title, position)
-        VALUES 
-          ($1, 'Backlog', 0),
-          ($1, 'In Progress', 1),
-          ($1, 'Review', 2),
-          ($1, 'Done', 3)
-        ON CONFLICT DO NOTHING
-      `,
-        [boardId]
-      );
-    }
-
-    console.log('База данных инициализирована успешно');
-  } catch (error) {
-    console.error('Ошибка при инициализации базы данных:', error);
-  } finally {
-    await pool.end();
-  }
-}
-
-initDb();

backend/scripts/revoke-all.js

@@ -1,26 +0,0 @@
-const hre = require('hardhat');
-
-async function main() {
-  const accessToken = await hre.ethers.getContractAt(
-    'AccessToken',
-    '0xF352c498cF0857F472dC473E4Dd39551E79B1063'
-  );
-
-  // Отзываем все токены от 1 до 3
-  for (let i = 1; i <= 3; i++) {
-    try {
-      const tx = await accessToken.revokeToken(i);
-      await tx.wait();
-      console.log(`Token ${i} revoked`);
-    } catch (error) {
-      console.log(`Token ${i} revoke error:`, error.message);
-    }
-  }
-}
-
-main()
-  .then(() => process.exit(0))
-  .catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });

backend/server.js

@@ -9,7 +9,7 @@ const { initializeVectorStore } = require('./services/vectorStore');
 const session = require('express-session');
 const { app, nonceStore } = require('./app');
 const usersRouter = require('./routes/users');
-const { router: authRouter } = require('./routes/auth');
+const authRouter = require('./routes/auth');
 const contractsRouter = require('./routes/contracts');
 const accessRouter = require('./routes/access');
 const path = require('path');
@@ -23,13 +23,14 @@ const fs = require('fs');
 const pgSession = require('connect-pg-simple')(session);
 const sessionStore = new pgSession({
   pool: pool,
-  tableName: 'session',
+  tableName: 'sessions',
   createTableIfMissing: true,
 });
 const helmet = require('helmet');
 // const csrf = require('csurf');
 // const cookieParser = require('cookie-parser');
 const messagesRouter = require('./routes/messages');
+const sessionMiddleware = require('./middleware/session');
 
 // Импорт сервисов
 const { initTelegramBot } = require('./services/telegram-service');
@@ -62,7 +63,7 @@ console.log('Ethers.js version:', ethers.version);
 // 1. CORS должен быть первым
 app.use(
   cors({
-    origin: ['http://localhost:5173', 'http://127.0.0.1:5173'],
+    origin: ['http://127.0.0.1:5173', 'http://localhost:5173'],
     credentials: true,
     methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
     allowedHeaders: ['Content-Type', 'Authorization', 'X-Auth-Nonce'],
@@ -76,50 +77,6 @@ app.use(helmet());
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 
-// 3. Затем сессии
-app.use(
-  session({
-    secret: process.env.SESSION_SECRET || 'your-secret-key',
-    resave: false,
-    saveUninitialized: false,
-    cookie: {
-      httpOnly: true,
-      secure: process.env.NODE_ENV === 'production', // В разработке можно установить false
-      sameSite: process.env.NODE_ENV === 'production' ? 'none' : 'lax',
-      maxAge: 24 * 60 * 60 * 1000, // 1 день
-    },
-    store: new pgSession({
-      pool: pool,
-      tableName: 'session',
-    }),
-  })
-);
-
-// Добавьте после настройки сессий
-app.use((req, res, next) => {
-  // console.log('Middleware для проверки сессии:', {
-  //   url: req.url,
-  //   method: req.method,
-  //   sessionID: req.sessionID,
-  //   session: req.session ? {
-  //     isAuthenticated: req.session.isAuthenticated,
-  //     authenticated: req.session.authenticated,
-  //     address: req.session.address,
-  //     isAdmin: req.session.isAdmin
-  //   } : null,
-  //   cookies: req.cookies,
-  //   headers: {
-  //     cookie: req.headers.cookie
-  //   }
-  // });
-  if (req.session.store) {
-    req.session.store.on('error', (error) => {
-      console.error('Session store error:', error);
-    });
-  }
-  next();
-});
-
 // Добавьте после настройки парсеров
 app.use((req, res, next) => {
   // if (req.method === 'POST' && req.headers['content-type'] === 'application/json') {
@@ -215,6 +172,9 @@ app.use((req, res, next) => {
 //   next(err);
 // });
 
+// Использовать импортированный middleware для сессий
+app.use(sessionMiddleware);
+
 async function initServices() {
   try {
     console.log('Инициализация сервисов...');
@@ -285,7 +245,17 @@ app.post('/api/verify', async (req, res) => {
       req.session.lastSignature = signature;
 
       // Сохраняем сессию
-      req.session.save();
+      await new Promise((resolve, reject) => {
+        req.session.save((err) => {
+          if (err) {
+            console.error('Ошибка при сохранении сессии:', err);
+            reject(err);
+          } else {
+            console.log('Сессия успешно сохранена');
+            resolve();
+          }
+        });
+      });
     } catch (error) {
       return res.status(401).json({ success: false, error: error.message });
     }
@@ -734,3 +704,11 @@ setTimeout(async () => {
     console.error('Ошибка при первоначальной очистке сессий:', err);
   }
 }, 5 * 60 * 1000);
+
+app.get('/session-debug', (req, res) => {
+  // Implementation of the endpoint
+});
+
+app.get('/check-sessions', async (req, res) => {
+  // Implementation of the endpoint
+});

backend/services/auth-service.js

@@ -0,0 +1,163 @@
+const db = require('../db');
+const { getContract } = require('../utils/contracts');
+const logger = require('../utils/logger');
+const { ethers } = require('ethers');
+const path = require('path');
+
+// Инициализируем провайдер
+const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
+
+const contractsDir = path.join(__dirname, '../artifacts/contracts/AccessToken.sol');
+
+/**
+ * Сервис для работы с аутентификацией и авторизацией
+ */
+class AuthService {
+  /**
+   * Проверяет наличие токена администратора для кошелька
+   * @param {string} walletAddress - Адрес кошелька
+   * @returns {Promise<boolean>} - Имеет ли кошелек токен администратора
+   */
+  async checkAdminToken(walletAddress) {
+    try {
+      if (!walletAddress) {
+        logger.error('Wallet address is undefined');
+        return false;
+      }
+
+      // Получаем контракт AccessToken
+      const accessToken = await getContract('AccessToken');
+      
+      // Проверяем роль пользователя
+      const role = await accessToken.checkRole(walletAddress);
+      
+      // 0 = ADMIN
+      return role === 0;
+    } catch (error) {
+      logger.error(`Error checking admin token: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Проверяет наличие токенов на кошельке и обновляет роль
+   * @param {string} walletAddress - Адрес кошелька
+   * @returns {Promise<boolean>} - Имеет ли пользователь права администратора
+   */
+  async checkTokensAndUpdateRole(walletAddress) {
+    try {
+      // Получаем ID пользователя по адресу кошелька
+      const userResult = await db.query(`
+        SELECT u.id FROM users u
+        JOIN user_identities ui ON u.id = ui.user_id
+        WHERE ui.identity_type = 'wallet' AND ui.identity_value = $1
+      `, [walletAddress]);
+      
+      if (userResult.rows.length === 0) {
+        logger.warn(`User with wallet ${walletAddress} not found`);
+        return false;
+      }
+      
+      const userId = userResult.rows[0].id;
+      
+      // Проверяем наличие токена администратора
+      const isAdmin = await this.checkAdminToken(walletAddress);
+      
+      // Обновляем роль в базе данных
+      await this.updateUserRole(userId, isAdmin ? 'admin' : 'user');
+      
+      logger.info(`User ${userId} with address ${walletAddress}: admin=${isAdmin}`);
+      
+      return isAdmin;
+    } catch (error) {
+      logger.error(`Error checking tokens: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Обновляет роль пользователя в базе данных
+   * @param {number} userId - ID пользователя
+   * @param {string} role - Новая роль ('admin' или 'user')
+   * @returns {Promise<boolean>} - Успешно ли обновлена роль
+   */
+  async updateUserRole(userId, role) {
+    try {
+      // Получаем ID роли
+      const roleResult = await db.query('SELECT id FROM roles WHERE name = $1', [role]);
+      
+      if (roleResult.rows.length === 0) {
+        logger.error(`Role ${role} not found`);
+        return false;
+      }
+      
+      const roleId = roleResult.rows[0].id;
+      
+      // Обновляем роль пользователя
+      await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [roleId, userId]);
+      
+      logger.info(`Updated role for user ${userId} to ${role}`);
+      return true;
+    } catch (error) {
+      logger.error(`Error updating user role: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Получает все токены доступа
+   * @returns {Promise<Array>} - Список токенов доступа
+   */
+  async getAllTokens() {
+    try {
+      const result = await db.query(`
+        SELECT * FROM access_tokens
+        ORDER BY created_at DESC
+      `);
+      
+      return result.rows.map(token => ({
+        id: token.id,
+        walletAddress: token.wallet_address,
+        role: token.role,
+        createdAt: token.created_at,
+        expiresAt: token.expires_at,
+      }));
+    } catch (error) {
+      logger.error(`Error getting all tokens: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Получает ID пользователя по идентификатору
+   * @param {string} identityType - Тип идентификатора ('wallet', 'email', 'telegram')
+   * @param {string} identityValue - Значение идентификатора
+   * @returns {Promise<number|null>} - ID пользователя или null, если пользователь не найден
+   */
+  async getUserIdByIdentity(identityType, identityValue) {
+    try {
+      // Нормализуем значение идентификатора
+      const normalizedValue = identityType === 'wallet' 
+        ? identityValue.toLowerCase() 
+        : identityValue;
+      
+      // Получаем ID пользователя
+      const result = await db.query(`
+        SELECT u.id FROM users u
+        JOIN user_identities ui ON u.id = ui.user_id
+        WHERE ui.identity_type = $1 AND LOWER(ui.identity_value) = LOWER($2)
+      `, [identityType, normalizedValue]);
+      
+      if (result.rows.length === 0) {
+        return null;
+      }
+      
+      return result.rows[0].id;
+    } catch (error) {
+      logger.error(`Error getting user ID by identity: ${error.message}`);
+      return null;
+    }
+  }
+}
+
+module.exports = new AuthService(); 

backend/test/AccessToken.test.js

@@ -1,41 +0,0 @@
-const { expect } = require('chai');
-const { ethers } = require('hardhat');
-
-describe('AccessToken', function () {
-  let AccessToken;
-  let accessToken;
-  let owner;
-  let addr1;
-  let addr2;
-
-  beforeEach(async function () {
-    [owner, addr1, addr2] = await ethers.getSigners();
-    AccessToken = await ethers.getContractFactory('AccessToken');
-    accessToken = await AccessToken.deploy();
-  });
-
-  describe('Minting', function () {
-    it('Should mint admin token', async function () {
-      await accessToken.mintAccessToken(addr1.address, 0);
-      expect(await accessToken.checkRole(addr1.address)).to.equal(0);
-    });
-
-    it('Should mint moderator token', async function () {
-      await accessToken.mintAccessToken(addr1.address, 1);
-      expect(await accessToken.checkRole(addr1.address)).to.equal(1);
-    });
-  });
-
-  describe('Access Control', function () {
-    it('Should fail for non-token holders', async function () {
-      await expect(accessToken.checkRole(addr1.address)).to.be.revertedWith('No active token');
-    });
-
-    it('Should revoke access', async function () {
-      await accessToken.mintAccessToken(addr1.address, 0);
-      const tokenId = await accessToken.activeTokens(addr1.address);
-      await accessToken.revokeToken(tokenId);
-      await expect(accessToken.checkRole(addr1.address)).to.be.revertedWith('No active token');
-    });
-  });
-});

backend/utils/access-check.js

@@ -1,172 +1,14 @@
-const { ethers } = require('ethers');
-require('dotenv').config();
 const db = require('../db');
-const contractArtifact = require('../artifacts/contracts/MyContract.sol/MyContract.json');
-const contractABI = contractArtifact.abi;
 const logger = require('./logger');
-const { getContract } = require('./contracts');
+const authService = require('../services/auth-service');
-
-// Проверяем наличие необходимых переменных окружения
-if (!process.env.ACCESS_TOKEN_ADDRESS) {
-  console.error('ACCESS_TOKEN_ADDRESS не указан в .env файле');
-}
-
-if (!process.env.ETHEREUM_NETWORK_URL) {
-  console.error('ETHEREUM_NETWORK_URL не указан в .env файле');
-}
-
-// Подключение к контракту
-const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_NETWORK_URL);
-let accessToken;
-
-try {
-  const AccessTokenABI = require('../artifacts/contracts/AccessToken.sol/AccessToken.json').abi;
-  accessToken = new ethers.Contract(process.env.ACCESS_TOKEN_ADDRESS, AccessTokenABI, provider);
-} catch (error) {
-  console.error('Ошибка инициализации контракта AccessToken:', error);
-}
 
 /**
- * Проверяет доступ и роль пользователя
+ * Проверяет токены всех пользователей и обновляет их роли
- * @param {string} address - Ethereum адрес пользователя
+ * @returns {Promise<void>}
- * @returns {Promise<{hasAccess: boolean, role: string|null}>}
- */
-async function checkAccess(address) {
-  try {
-    if (!address || !accessToken) {
-      return { hasAccess: false, role: null };
-    }
-
-    // Проверяем активный токен
-    const activeTokenId = await accessToken.activeTokens(address);
-    if (activeTokenId.toString() === '0') {
-      return { hasAccess: false, role: null };
-    }
-
-    // Получаем роль
-    const roleId = await accessToken.checkRole(address);
-    const roles = ['ADMIN', 'MODERATOR', 'SUPPORT'];
-    const role = roles[roleId];
-
-    return {
-      hasAccess: true,
-      role,
-      tokenId: activeTokenId.toString(),
-    };
-  } catch (error) {
-    console.error('Access check error:', error);
-    return { hasAccess: false, role: null };
-  }
-}
-
-// Функция для проверки, является ли пользователь администратором
-async function checkIfAdmin(address) {
-  try {
-    console.log('Проверка прав администратора для адреса:', address);
-
-    // Проверяем в базе данных
-    const result = await db.query('SELECT is_admin FROM users WHERE address = $1', [address]);
-
-    if (result.rows.length === 0) {
-      console.log(`Пользователь с адресом ${address} не найден в базе данных`);
-      return false;
-    }
-
-    const isAdmin = result.rows[0].is_admin;
-    console.log(`Пользователь с адресом ${address} имеет статус администратора:`, isAdmin);
-
-    return isAdmin;
-  } catch (error) {
-    console.error('Ошибка при проверке прав администратора:', error);
-    return false;
-  }
-}
-
-/**
- * Проверяет баланс токенов пользователя и обновляет его роль
- * @param {string} address - Адрес кошелька пользователя
- * @returns {Promise<boolean>} - Имеет ли пользователь права администратора
- */
-async function checkTokenBalanceAndUpdateRole(address) {
-  try {
-    // Получение контракта токенов
-    const accessTokenContract = await getContract('AccessToken');
-    
-    // Проверка баланса
-    const balance = await accessTokenContract.balanceOf(address);
-    
-    // Минимальное количество токенов для прав администратора
-    const minTokens = ethers.utils.parseUnits(process.env.MIN_ADMIN_TOKENS || "1", 18);
-    
-    const isAdmin = balance.gte(minTokens);
-    
-    // Получение ID пользователя по адресу кошелька
-    const userResult = await db.query(`
-      SELECT u.id FROM users u
-      JOIN user_identities ui ON u.id = ui.user_id
-      WHERE ui.identity_type = 'wallet' AND ui.identity_value = $1
-    `, [address.toLowerCase()]);
-    
-    if (userResult.rows.length > 0) {
-      const userId = userResult.rows[0].id;
-      
-      // Получение ID роли
-      const roleResult = await db.query(
-        'SELECT id FROM roles WHERE name = $1',
-        [isAdmin ? 'admin' : 'user']
-      );
-      
-      if (roleResult.rows.length > 0) {
-        const roleId = roleResult.rows[0].id;
-        
-        // Обновление роли пользователя
-        await db.query(
-          'UPDATE users SET role_id = $1, last_token_check = NOW() WHERE id = $2',
-          [roleId, userId]
-        );
-        
-        logger.info(`Updated user ${userId} role to ${isAdmin ? 'admin' : 'user'} based on token balance`);
-      }
-    }
-    
-    return isAdmin;
-  } catch (error) {
-    logger.error(`Error checking token balance for ${address}: ${error.message}`);
-    return false;
-  }
-}
-
-/**
- * Получает информацию о пользователе, включая его роль
- * @param {number} userId - ID пользователя
- * @returns {Promise<Object>} - Информация о пользователе
- */
-async function getUserInfo(userId) {
-  try {
-    const result = await db.query(`
-      SELECT u.id, u.username, u.preferred_language, r.name as role
-      FROM users u
-      LEFT JOIN roles r ON u.role_id = r.id
-      WHERE u.id = $1
-    `, [userId]);
-    
-    if (result.rows.length === 0) {
-      return null;
-    }
-    
-    return result.rows[0];
-  } catch (error) {
-    logger.error(`Error getting user info for ${userId}: ${error.message}`);
-    return null;
-  }
-}
-
-/**
- * Запускает проверку токенов для всех пользователей
  */
 async function checkAllUsersTokens() {
   try {
-    // Получение всех пользователей с кошельками
+    // Получаем всех пользователей с кошельками
     const walletUsers = await db.query(`
       SELECT u.id, ui.identity_value as address 
       FROM users u
@@ -174,23 +16,24 @@ async function checkAllUsersTokens() {
       WHERE ui.identity_type = 'wallet'
     `);
     
-    logger.info(`Checking token balances for ${walletUsers.rows.length} users`);
+    logger.info(`Checking tokens for ${walletUsers.rows.length} users`);
     
     for (const user of walletUsers.rows) {
-      // Проверка баланса токенов
+      try {
-      const hasTokens = await checkTokenBalanceAndUpdateRole(user.address);
+        // Используем существующий метод для проверки токенов и обновления роли
-      
+        const isAdmin = await authService.checkTokensAndUpdateRole(user.address);
-      logger.info(`User ${user.id} with address ${user.address}: admin=${hasTokens}`);
+        logger.info(`Updated user ${user.id} with address ${user.address}: admin=${isAdmin}`);
+      } catch (error) {
+        logger.error(`Error checking tokens for user ${user.id}: ${error.message}`);
+      }
     }
+    
+    logger.info('Token check completed');
   } catch (error) {
-    logger.error(`Error checking token balances: ${error.message}`);
+    logger.error(`Error checking all users tokens: ${error.message}`);
   }
 }
 
 module.exports = {
-  checkAccess,
-  checkIfAdmin,
-  checkTokenBalanceAndUpdateRole,
-  getUserInfo,
   checkAllUsersTokens
 };

backend/utils/auth.js

@@ -1,184 +1,152 @@
-const { SiweMessage } = require('siwe');
 const { ethers } = require('ethers');
-const AccessTokenABI = require('../artifacts/contracts/AccessToken.sol/AccessToken.json').abi;
+const db = require('../db');
-require('dotenv').config();
+const logger = require('./logger');
-const { pool } = require('../db');
+const authService = require('../services/auth-service');
+const { USER_ROLES, IDENTITY_TYPES } = require('./constants');
 
-// В ethers.js v6.x используется JsonRpcProvider напрямую
+// Инициализация провайдера
 const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
-const accessToken = new ethers.Contract(process.env.ACCESS_TOKEN_ADDRESS, AccessTokenABI, provider);
-
-// Проверяем наличие адреса контракта
-if (!process.env.ACCESS_TOKEN_ADDRESS) {
-  console.error('ACCESS_TOKEN_ADDRESS не указан в .env файле');
-}
 
 /**
  * Проверяет подпись сообщения
- * @param {Object} message - Сообщение для проверки
+ * @param {string} nonce - Независимый идентификатор
- * @param {string} signature - Подпись сообщения
+ * @param {string} signature - Подпись
  * @param {string} address - Адрес кошелька
  * @returns {Promise<boolean>} - Результат проверки
  */
-async function verifySignature(message, signature, address) {
+async function verifySignature(nonce, signature, address) {
   try {
-    // Формируем сообщение для проверки
+    // Создаем сообщение для проверки
-    const domain = message.domain || 'localhost';
+    const message = `Sign this message to authenticate with our app: ${nonce}`;
-    const statement = message.statement || 'Sign in with Ethereum to the app.';
-    const uri = message.uri || 'http://localhost:8000';
-    const version = message.version || '1';
-    const chainId = message.chainId || '1';
-    const nonce = message.nonce;
     
-    const messageToVerify = `${domain} wants you to sign in with your Ethereum account:
+    // Восстанавливаем адрес из подписи
-${address}
+    const recoveredAddress = ethers.verifyMessage(message, signature);
-
-${statement}
-
-URI: ${uri}
-Version: ${version}
-Chain ID: ${chainId}
-Nonce: ${nonce}
-`;
-
-    // В ethers.js v6.x используется verifyMessage напрямую
-    const recoveredAddress = ethers.verifyMessage(messageToVerify, signature);
     
+    // Проверяем, что восстановленный адрес совпадает с предоставленным
     return recoveredAddress.toLowerCase() === address.toLowerCase();
   } catch (error) {
-    console.error('Signature verification error:', error);
+    console.error('Error verifying signature:', error);
     return false;
   }
 }
 
-async function checkAccess(address) {
+/**
-  // Временная заглушка
+ * Проверяет, является ли пользователь администратором
-  return { hasAccess: false, role: null };
+ * @param {string} address - Адрес кошелька
-}
+ * @returns {Promise<boolean>} - Является ли пользователь администратором
-
+ */
-async function verifyAndCheckAccess(message, signature, address) {
+async function checkUserRole(address) {
-  // Проверяем подпись
-  const verified = await verifySignature(message, signature, address);
-  if (!verified) {
-    return {
-      verified: false,
-      access: { hasAccess: false },
-    };
-  }
-
-  // Проверяем доступ
-  const access = await checkAccess(address);
-
-  return {
-    verified: true,
-    access,
-  };
-}
-
-// Функция для поиска или создания пользователя
-async function findOrCreateUser(identifier, identityType = 'wallet') {
   try {
-    // Проверяем, является ли адрес адресом администратора
+    // Проверяем наличие токена администратора
-    const isAdmin = identityType === 'wallet' && 
+    const isAdmin = await authService.checkAdminToken(address);
-                    identifier.toLowerCase() === process.env.ADMIN_WALLET_ADDRESS.toLowerCase();
+    return isAdmin;
+  } catch (error) {
+    console.error('Error checking user role:', error);
+    return false;
+  }
+}
 
-    console.log(`Проверка на администратора: ${identifier.toLowerCase()} === ${process.env.ADMIN_WALLET_ADDRESS.toLowerCase()} = ${isAdmin}`);
+/**
+ * Проверяет доступ пользователя
+ * @param {string} walletAddress - Адрес кошелька
+ * @returns {Promise<Object>} - Информация о доступе
+ */
+async function checkAccess(walletAddress) {
+  try {
+    // Проверяем наличие токена администратора
+    const isAdmin = await authService.checkAdminToken(walletAddress);
     
-    // Проверяем, существует ли пользователь с таким идентификатором
+    // Получаем или создаем пользователя
-    const identityResult = await pool.query(
+    const userId = await findOrCreateUser(walletAddress);
-      'SELECT user_id FROM user_identities WHERE identity_type = $1 AND identity_value = $2',
-      [identityType, identifier.toLowerCase()]
-    );
     
-    let userId;
-    let isNewUser = false;
-
-    if (identityResult.rows.length > 0) {
-      // Пользователь найден
-      userId = identityResult.rows[0].user_id;
-      console.log(`Найден существующий пользователь с ID: ${userId}`);
-      
-      // Обновляем статус администратора, если это необходимо
-      if (isAdmin) {
-        await pool.query(
-          'UPDATE users SET is_admin = true WHERE id = $1',
-          [userId]
-        );
-        console.log(`Обновлен статус администратора для пользователя ${userId}`);
-      }
-    } else {
-      // Создаем нового пользователя с явным указанием всех необходимых полей
-      const username = `user_${Date.now()}`;
-      
-      // Проверяем существование роли USER или ADMIN
-      const roleName = isAdmin ? 'ADMIN' : 'USER';
-      const roleCheck = await pool.query('SELECT id FROM roles WHERE name = $1', [roleName]);
-      let roleId;
-      
-      if (roleCheck.rows.length > 0) {
-        roleId = roleCheck.rows[0].id;
-      } else {
-        // Если роли нет, создаем её
-        const newRole = await pool.query(
-          'INSERT INTO roles (name, description) VALUES ($1, $2) RETURNING id',
-          [roleName, isAdmin ? 'Administrator role' : 'Regular user role']
-        );
-        roleId = newRole.rows[0].id;
-      }
-      
-      // Создаем пользователя с обязательными полями
-      const userResult = await pool.query(
-        `INSERT INTO users (username, role_id, address, created_at, is_admin) 
-         VALUES ($1, $2, $3, NOW(), $4) 
-         RETURNING id`,
-        [username, roleId, identifier.toLowerCase(), isAdmin]
-      );
-      
-      userId = userResult.rows[0].id;
-      isNewUser = true;
-
-      // Создаем запись в таблице идентификаторов
-      await pool.query(
-        'INSERT INTO user_identities (user_id, identity_type, identity_value, verified, created_at) VALUES ($1, $2, $3, true, NOW())',
-        [userId, identityType, identifier.toLowerCase()]
-      );
-
-      console.log(`Создан новый пользователь с ID: ${userId}, isAdmin: ${isAdmin}`);
-    }
-
-    // Получаем информацию о пользователе
-    try {
-      const userInfo = await pool.query(
-        `SELECT u.id, u.username, u.is_admin, r.name as role
-         FROM users u
-         JOIN roles r ON u.role_id = r.id
-         WHERE u.id = $1`,
-        [userId]
-      );
-
-      if (userInfo.rows.length > 0) {
-        return userInfo.rows[0];
-      }
-    } catch (err) {
-      console.error('Ошибка при получении информации о пользователе:', err);
-    }
-
-    // Если не удалось получить полную информацию, возвращаем базовую
     return {
-      id: userId,
+      userId,
-      username: isNewUser ? `user_${Date.now()}` : 'unknown',
+      isAdmin,
-      is_admin: isAdmin,
+      hasAccess: true
-      role: isAdmin ? 'ADMIN' : 'USER'
     };
   } catch (error) {
-    console.error('Ошибка при поиске/создании пользователя:', error);
+    logger.error(`Error checking access: ${error.message}`);
+    return {
+      hasAccess: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Находит или создает пользователя по адресу кошелька
+ * @param {string} address - Адрес кошелька
+ * @returns {Promise<Object>} - ID пользователя и роль
+ */
+async function findOrCreateUser(address) {
+  try {
+    // Проверяем, существует ли пользователь
+    const userResult = await db.query('SELECT * FROM users WHERE LOWER(address) = LOWER($1)', [address]);
+    
+    let userId;
+    let isAdmin = false;
+    
+    if (userResult.rows.length === 0) {
+      // Если пользователь не найден, создаем его
+      // Получаем ID роли 'user'
+      const roleResult = await db.query('SELECT id FROM roles WHERE name = $1', ['user']);
+      if (roleResult.rows.length === 0) {
+        throw new Error('Role "user" not found');
+      }
+      const roleId = roleResult.rows[0].id;
+      
+      // Создаем пользователя с ролью 'user'
+      const newUserResult = await db.query(
+        'INSERT INTO users (address, role_id, created_at) VALUES (LOWER($1), $2, NOW()) RETURNING id',
+        [address, roleId]
+      );
+      
+      userId = newUserResult.rows[0].id;
+      
+      // Проверяем, является ли пользователь администратором
+      isAdmin = await checkUserRole(address);
+      
+      // Если пользователь администратор, обновляем его роль
+      if (isAdmin) {
+        const adminRoleResult = await db.query('SELECT id FROM roles WHERE name = $1', ['admin']);
+        if (adminRoleResult.rows.length > 0) {
+          const adminRoleId = adminRoleResult.rows[0].id;
+          await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [adminRoleId, userId]);
+        }
+      }
+    } else {
+      // Если пользователь найден, получаем его ID и роль
+      userId = userResult.rows[0].id;
+      
+      // Проверяем, является ли пользователь администратором по роли
+      const roleResult = await db.query('SELECT name FROM roles WHERE id = $1', [userResult.rows[0].role_id]);
+      isAdmin = roleResult.rows.length > 0 && roleResult.rows[0].name === 'admin';
+      
+      // Проверяем, является ли пользователь администратором по токену
+      const isAdminByToken = await checkUserRole(address);
+      
+      // Обновляем роль пользователя, если она изменилась
+      if (isAdminByToken !== isAdmin) {
+        const roleNameToSet = isAdminByToken ? 'admin' : 'user';
+        const roleToSetResult = await db.query('SELECT id FROM roles WHERE name = $1', [roleNameToSet]);
+        if (roleToSetResult.rows.length > 0) {
+          const roleIdToSet = roleToSetResult.rows[0].id;
+          await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [roleIdToSet, userId]);
+          isAdmin = isAdminByToken;
+        }
+      }
+    }
+    
+    return { userId, isAdmin };
+  } catch (error) {
+    console.error('Error finding or creating user:', error);
     throw error;
   }
 }
 
 module.exports = {
-  verifyAndCheckAccess,
   verifySignature,
   checkAccess,
-  findOrCreateUser
+  findOrCreateUser,
+  checkUserRole
 }; 

backend/utils/constants.js

@@ -0,0 +1,58 @@
+// Роли пользователей
+const USER_ROLES = {
+  USER: 1,
+  ADMIN: 2
+};
+
+// Типы идентификаторов
+const IDENTITY_TYPES = {
+  WALLET: 'wallet',
+  EMAIL: 'email',
+  TELEGRAM: 'telegram'
+};
+
+// Каналы сообщений
+const MESSAGE_CHANNELS = {
+  WEB: 'web',
+  TELEGRAM: 'telegram',
+  EMAIL: 'email'
+};
+
+// Типы отправителей сообщений
+const SENDER_TYPES = {
+  USER: 'user',
+  AI: 'ai',
+  ADMIN: 'admin'
+};
+
+// Коды ошибок
+const ERROR_CODES = {
+  UNAUTHORIZED: 'unauthorized',
+  FORBIDDEN: 'forbidden',
+  NOT_FOUND: 'not_found',
+  INTERNAL_ERROR: 'internal_error',
+  BAD_REQUEST: 'bad_request'
+};
+
+// Настройки сессии
+const SESSION_CONFIG = {
+  COOKIE_MAX_AGE: 24 * 60 * 60 * 1000, // 24 часа
+  COOKIE_SECURE: process.env.NODE_ENV === 'production',
+  COOKIE_SAME_SITE: 'lax'
+};
+
+// Настройки API
+const API_CONFIG = {
+  RATE_LIMIT: 100, // запросов в минуту
+  TIMEOUT: 30000 // 30 секунд
+};
+
+module.exports = {
+  USER_ROLES,
+  IDENTITY_TYPES,
+  MESSAGE_CHANNELS,
+  SENDER_TYPES,
+  ERROR_CODES,
+  SESSION_CONFIG,
+  API_CONFIG
+}; 

backend/utils/contracts.js

@@ -3,36 +3,99 @@ const fs = require('fs');
 const path = require('path');
 const logger = require('./logger');
 
+// Инициализация провайдера
+const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
+
+// Путь к директории с ABI контрактов
+const contractsDir = path.join(__dirname, '../artifacts/contracts/AccessToken.sol');
+
+// Получение ABI контракта
+const accessTokenJSON = require('../artifacts/contracts/AccessToken.sol/AccessToken.json');
+const accessTokenABI = accessTokenJSON.abi;
+
+// Проверка, что ABI является массивом
+if (!Array.isArray(accessTokenABI)) {
+  console.error('ABI is not an array:', accessTokenABI);
+  // Если ABI не является массивом, создайте массив вручную
+  const manualABI = [
+    "function mintAccessToken(address to, uint8 role) public",
+    "function checkRole(address user) public view returns (uint8)",
+    "function revokeToken(uint256 tokenId) public",
+    // Добавьте другие функции, которые вам нужны
+  ];
+  
+  // Создание экземпляра контракта с ручным ABI
+  const contractAddress = process.env.ACCESS_TOKEN_ADDRESS;
+  const accessTokenContract = new ethers.Contract(contractAddress, manualABI, provider);
+  
+  module.exports = {
+    accessTokenContract,
+    getContract,
+    provider
+  };
+} else {
+  // Если ABI является массивом, используйте его
+  const contractAddress = process.env.ACCESS_TOKEN_ADDRESS;
+  const accessTokenContract = new ethers.Contract(contractAddress, accessTokenABI, provider);
+  
+  module.exports = {
+    accessTokenContract,
+    getContract,
+    provider
+  };
+}
+
+// Кэш для хранения экземпляров контрактов
+const contractsCache = {};
+
 /**
  * Получает экземпляр контракта по его имени
- * @param {string} contractName - Имя контракта (например, 'AccessToken')
+ * @param {string} contractName - Имя контракта
  * @returns {Promise<ethers.Contract>} - Экземпляр контракта
  */
 async function getContract(contractName) {
   try {
-    // Путь к артефакту контракта
+    console.log(`Getting contract: ${contractName}`);
-    const artifactPath = path.join(__dirname, '..', 'artifacts', 'contracts', `${contractName}.sol`, `${contractName}.json`);
     
-    // Проверка существования файла
+    // Проверяем, есть ли контракт в кэше
-    if (!fs.existsSync(artifactPath)) {
+    if (contractsCache[contractName]) {
-      throw new Error(`Артефакт контракта ${contractName} не найден по пути ${artifactPath}`);
+      console.log(`Using cached contract: ${contractName}`);
+      return contractsCache[contractName];
     }
     
-    // Загрузка ABI из артефакта
+    // Получаем адрес контракта из переменных окружения
-    const contractArtifact = require(artifactPath);
+    const contractAddress = process.env.ACCESS_TOKEN_ADDRESS; // или ACCESS_TOKEN_CONTRACT_ADDRESS
-    const contractABI = contractArtifact.abi;
     
-    // Получение адреса контракта из переменных окружения
-    const contractAddress = process.env[`${contractName.toUpperCase()}_ADDRESS`];
     if (!contractAddress) {
-      throw new Error(`Адрес контракта ${contractName} не найден в переменных окружения`);
+      throw new Error(`Contract address for ${contractName} not found in environment variables`);
     }
     
-    // Подключение к провайдеру
+    // Путь к файлу с ABI контракта
-    const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_NETWORK_URL);
+    const abiPath = path.join(contractsDir, `${contractName}.json`);
     
-    // Создание экземпляра контракта
+    // Проверяем, существует ли файл с ABI
-    const contract = new ethers.Contract(contractAddress, contractABI, provider);
+    if (!fs.existsSync(abiPath)) {
+      throw new Error(`ABI file for ${contractName} not found at ${abiPath}`);
+    }
+    
+    // Читаем ABI из файла
+    const abiJson = fs.readFileSync(abiPath, 'utf8');
+    const contractJSON = JSON.parse(abiJson);
+    const abi = contractJSON.abi; // Получаем ABI из свойства abi
+    
+    console.log(`ABI for ${contractName}:`, abi);
+    
+    // Проверяем, что ABI является массивом
+    if (!Array.isArray(abi)) {
+      console.error(`ABI for ${contractName} is not an array:`, abi);
+      throw new Error(`ABI for ${contractName} is not an array`);
+    }
+    
+    // Создаем экземпляр контракта
+    const contract = new ethers.Contract(contractAddress, abi, provider);
+    
+    // Сохраняем контракт в кэше
+    contractsCache[contractName] = contract;
     
     return contract;
   } catch (error) {
@@ -40,7 +103,3 @@ async function getContract(contractName) {
     throw error;
   }
 }
-
-module.exports = {
-  getContract
-};

backend/utils/db.js

@@ -1,2 +0,0 @@
-// Реэкспорт основного модуля db
-module.exports = require('../db');

backend/utils/identity-linker.js

@@ -1,10 +1,5 @@
-const { Pool } = require('pg');
+const db = require('../db');
-
+const logger = require('./logger');
-// Подключение к БД
-const pool = new Pool({
-  connectionString: process.env.DATABASE_URL,
-  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
-});
 
 /**
  * Связывает идентификатор с пользователем
@@ -16,7 +11,7 @@ const pool = new Pool({
 async function linkIdentity(userId, identityType, identityValue) {
   try {
     // Проверяем, существует ли уже такой идентификатор
-    const existingResult = await pool.query(
+    const existingResult = await db.query(
       'SELECT * FROM user_identities WHERE identity_type = $1 AND identity_value = $2',
       [identityType, identityValue]
     );
@@ -32,7 +27,7 @@ async function linkIdentity(userId, identityType, identityValue) {
     }
 
     // Добавляем новую связь
-    await pool.query(
+    await db.query(
       'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
       [userId, identityType, identityValue]
     );
@@ -53,7 +48,7 @@ async function linkIdentity(userId, identityType, identityValue) {
  */
 async function getUserIdByIdentity(identityType, identityValue) {
   try {
-    const result = await pool.query(
+    const result = await db.query(
       'SELECT user_id FROM user_identities WHERE identity_type = $1 AND identity_value = $2',
       [identityType, identityValue]
     );
@@ -76,7 +71,7 @@ async function getUserIdByIdentity(identityType, identityValue) {
  */
 async function getUserIdentities(userId) {
   try {
-    const result = await pool.query(
+    const result = await db.query(
       'SELECT identity_type, identity_value FROM user_identities WHERE user_id = $1',
       [userId]
     );

backend/utils/wallet.js

@@ -1,4 +0,0 @@
-import { ethers } from 'ethers';
-
-const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_NETWORK_URL);
-const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

frontend/src/App.vue

@@ -45,54 +45,22 @@ async function checkSession() {
 // Функция для обновления сессии
 async function refreshSession() {
   try {
-    const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
-
     // Проверяем, есть ли адрес пользователя
-    if (!authStore.address) {
+    if (!authStore.user || !authStore.user.address) {
       console.log('Нет адреса пользователя для обновления сессии');
       return;
     }
 
-    console.log('Попытка обновления сессии для адреса:', authStore.address);
+    const response = await axios.post('/api/auth/refresh-session', 
+      { address: authStore.user.address },
+      { withCredentials: true }
+    );
     
-    // Сначала проверяем, доступен ли маршрут
+    if (response.data.success) {
-    try {
+      console.log('Сессия успешно обновлена');
-      const response = await axios.post(
-        `${apiUrl}/api/auth/refresh-session`,
-        {
-          address: authStore.address,
-        },
-        {
-          withCredentials: true,
-        }
-      );
-
-      console.log('Сессия обновлена:', response.data);
-    } catch (error) {
-      if (error.response && error.response.status === 404) {
-        console.log('Маршрут refresh-session не найден, пробуем альтернативный метод');
-
-        // Альтернативный метод: используем маршрут проверки аутентификации
-        const checkResponse = await axios.get(`${apiUrl}/api/auth/check`, {
-          withCredentials: true,
-          headers: {
-            Authorization: `Bearer ${authStore.address}`,
-          },
-        });
-
-        console.log('Проверка аутентификации:', checkResponse.data);
-      } else {
-        throw error;
-      }
     }
   } catch (error) {
     console.error('Ошибка при обновлении сессии:', error);
-
-    // Добавляем более подробную информацию об ошибке
-    if (error.response) {
-      console.error('Статус ответа:', error.response.status);
-      console.error('Данные ответа:', error.response.data);
-    }
   }
 }
 
@@ -110,40 +78,14 @@ onMounted(async () => {
     
     if (response.data.authenticated) {
       // Если сессия активна, обновляем состояние аутентификации
-      authStore.updateAuthState({
+      authStore.isAuthenticated = response.data.authenticated;
-        authenticated: response.data.authenticated,
+      authStore.user = { address: response.data.address };
-        address: response.data.address,
+      authStore.isAdmin = response.data.isAdmin;
-        isAdmin: response.data.isAdmin,
+      authStore.authType = 'wallet';
-        authType: 'wallet'
-      });
       
       console.log('Сессия восстановлена:', response.data);
     } else {
       console.log('Нет активной сессии');
-      
-      // Если в localStorage есть адрес, пробуем восстановить сессию
-      const savedAddress = localStorage.getItem('walletAddress');
-      if (savedAddress) {
-        console.log('Найден сохраненный адрес:', savedAddress);
-        try {
-          const refreshResponse = await axios.post('/api/auth/refresh-session', 
-            { address: savedAddress },
-            { withCredentials: true }
-          );
-          
-          if (refreshResponse.data.success) {
-            authStore.updateAuthState({
-              authenticated: true,
-              address: savedAddress,
-              isAdmin: refreshResponse.data.user.isAdmin,
-              authType: 'wallet'
-            });
-            console.log('Сессия восстановлена через refresh-session');
-          }
-        } catch (refreshError) {
-          console.error('Ошибка при восстановлении сессии:', refreshError);
-        }
-      }
     }
   } catch (error) {
     console.error('Ошибка при проверке сессии:', error);

frontend/src/api/auth.js

@@ -1,4 +0,0 @@
-import axios from 'axios';
-
-// Настройка axios для работы с куками
-axios.defaults.withCredentials = true;

frontend/src/api/axios.js

@@ -0,0 +1,26 @@
+import axios from 'axios';
+
+// Создаем экземпляр axios с базовым URL
+const api = axios.create({
+  baseURL: 'http://localhost:8000',
+  withCredentials: true, // Важно для передачи куков между запросами
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+// Удаляем перехватчик, который добавлял заголовок Authorization из localStorage
+// api.interceptors.request.use(
+//   (config) => {
+//     const address = localStorage.getItem('walletAddress');
+//     if (address) {
+//       config.headers.Authorization = `Bearer ${address}`;
+//     }
+//     return config;
+//   },
+//   (error) => {
+//     return Promise.reject(error);
+//   }
+// );
+
+export default api;

frontend/src/components/AccessControl.vue

@@ -1,188 +0,0 @@
-<template>
-  <div class="access-control">
-    <div v-if="error" class="error-message">
-      {{ error }}
-    </div>
-    <div v-else-if="loading" class="loading-message">Загрузка...</div>
-    <div v-else>
-      <div v-if="!isConnected" class="alert alert-warning">
-        Подключите ваш кошелек для проверки доступа
-      </div>
-      <div v-else-if="accessInfo.hasAccess" class="alert alert-success">
-        <strong>Доступ разрешен!</strong>
-        <div>Токен: {{ accessInfo.token }}</div>
-        <div>Роль: {{ accessInfo.role }}</div>
-        <div>Истекает: {{ formatDate(accessInfo.expiresAt) }}</div>
-      </div>
-      <div v-else class="alert alert-danger">
-        <strong>Доступ запрещен!</strong>
-        <p>У вас нет активного токена доступа.</p>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { ref, onMounted, watch } from 'vue';
-import axios from 'axios';
-import { useAuthStore } from '../stores/auth';
-
-const authStore = useAuthStore();
-const address = ref('');
-const isConnected = ref(true);
-const loading = ref(false);
-const error = ref(null);
-const accessInfo = ref({
-  hasAccess: false,
-  token: '',
-  role: '',
-  expiresAt: null,
-});
-
-// Форматирование даты
-function formatDate(timestamp) {
-  if (!timestamp) return 'Н/Д';
-  return new Date(timestamp).toLocaleString();
-}
-
-// Проверка доступа
-async function checkAccess() {
-  if (!isConnected.value || !address.value) return;
-
-  loading.value = true;
-  error.value = null;
-
-  try {
-    const response = await axios.get('/access/check', {
-      headers: {
-        'x-wallet-address': address.value,
-      },
-    });
-
-    accessInfo.value = response.data;
-  } catch (err) {
-    console.error('Ошибка проверки доступа:', err);
-    error.value = err.response?.data?.error || 'Ошибка проверки доступа';
-    accessInfo.value = { hasAccess: false };
-  } finally {
-    loading.value = false;
-  }
-}
-
-// Проверяем доступ при изменении адреса
-watch(
-  () => address.value,
-  () => {
-    checkAccess();
-  }
-);
-
-// Проверяем доступ при монтировании компонента
-onMounted(() => {
-  if (isConnected.value && address.value) {
-    checkAccess();
-  }
-});
-
-async function loadTokens() {
-  try {
-    console.log('Загрузка токенов...');
-    loading.value = true;
-
-    // Добавляем withCredentials для передачи куки с сессией
-    const response = await axios.get('/api/access/tokens', {
-      withCredentials: true,
-    });
-
-    console.log('Ответ API:', response.data);
-
-    if (response.data && response.data.length > 0) {
-      // Если есть токены, берем первый активный
-      const activeToken = response.data.find((token) => {
-        const expiresAt = new Date(token.expires_at);
-        return expiresAt > new Date();
-      });
-
-      if (activeToken) {
-        accessInfo.value = {
-          hasAccess: true,
-          token: activeToken.id,
-          role: activeToken.role,
-          expiresAt: activeToken.expires_at,
-        };
-      } else {
-        accessInfo.value = { hasAccess: false };
-      }
-    } else {
-      accessInfo.value = { hasAccess: false };
-    }
-  } catch (error) {
-    console.error('Ошибка при загрузке токенов:', error);
-    error.value = 'Ошибка при проверке доступа: ' + (error.response?.data?.error || error.message);
-    accessInfo.value = { hasAccess: false };
-  } finally {
-    loading.value = false;
-  }
-}
-
-onMounted(async () => {
-  console.log('Компонент AccessControl загружен');
-  console.log('isAdmin:', authStore.isAdmin);
-  await loadTokens();
-});
-</script>
-
-<style scoped>
-.access-control {
-  margin: 20px 0;
-  padding: 15px;
-  border: 1px solid #ddd;
-  border-radius: 4px;
-}
-
-.alert {
-  padding: 10px 15px;
-  margin-bottom: 10px;
-  border-radius: 4px;
-}
-
-.alert-warning {
-  background-color: #fff3cd;
-  border: 1px solid #ffeeba;
-  color: #856404;
-}
-
-.alert-info {
-  background-color: #d1ecf1;
-  border: 1px solid #bee5eb;
-  color: #0c5460;
-}
-
-.alert-danger {
-  background-color: #f8d7da;
-  border: 1px solid #f5c6cb;
-  color: #721c24;
-}
-
-.alert-success {
-  background-color: #d4edda;
-  border: 1px solid #c3e6cb;
-  color: #155724;
-}
-
-.error-message {
-  color: #721c24;
-  background-color: #f8d7da;
-  padding: 10px;
-  border-radius: 4px;
-  margin-bottom: 15px;
-}
-
-.loading-message {
-  color: #0c5460;
-  background-color: #d1ecf1;
-  padding: 10px;
-  border-radius: 4px;
-  margin-bottom: 15px;
-}
-</style>

frontend/src/components/AccessTokenManager.vue

@@ -1,161 +0,0 @@
-<template>
-  <div class="access-token-manager">
-    <h3>Управление токенами доступа</h3>
-    <div class="token-actions">
-      <button @click="mintNewToken">Выпустить новый токен</button>
-      <button @click="loadTokens">Обновить список</button>
-    </div>
-
-    <div v-if="loading">Загрузка...</div>
-
-    <table v-else-if="tokens.length > 0" class="tokens-table">
-      <thead>
-        <tr>
-          <th>ID</th>
-          <th>Владелец</th>
-          <th>Роль</th>
-          <th>Действия</th>
-        </tr>
-      </thead>
-      <tbody>
-        <tr v-for="token in tokens" :key="token.id">
-          <td>{{ token.id }}</td>
-          <td>{{ token.owner }}</td>
-          <td>{{ getRoleName(token.role) }}</td>
-          <td>
-            <button @click="revokeToken(token.id)">Отозвать</button>
-          </td>
-        </tr>
-      </tbody>
-    </table>
-
-    <div v-else>Нет доступных токенов</div>
-  </div>
-</template>
-
-<script setup>
-import { ref, onMounted } from 'vue';
-import axios from 'axios';
-
-const tokens = ref([]);
-const loading = ref(false);
-
-const roles = {
-  0: 'Администратор',
-  1: 'Модератор',
-  2: 'Пользователь',
-};
-
-function getRoleName(roleId) {
-  return roles[roleId] || 'Неизвестная роль';
-}
-
-async function loadTokens() {
-  try {
-    console.log('Загрузка токенов...');
-    loading.value = true;
-
-    // Добавляем withCredentials для передачи куки с сессией
-    const response = await axios.get('/api/access/tokens', {
-      withCredentials: true,
-    });
-
-    console.log('Ответ API:', response.data);
-    tokens.value = response.data;
-  } catch (error) {
-    console.error('Ошибка при загрузке токенов:', error);
-    if (error.response) {
-      console.error('Статус ошибки:', error.response.status);
-      console.error('Данные ошибки:', error.response.data);
-    } else if (error.request) {
-      console.error('Запрос без ответа:', error.request);
-    } else {
-      console.error('Ошибка настройки запроса:', error.message);
-    }
-  } finally {
-    loading.value = false;
-  }
-}
-
-async function mintNewToken() {
-  try {
-    const walletAddress = prompt('Введите адрес получателя:');
-    if (!walletAddress) return;
-
-    const role = prompt('Введите роль (ADMIN, MODERATOR, USER):');
-    if (!role) return;
-
-    const expiresInDays = prompt('Введите срок действия в днях:');
-    if (!expiresInDays) return;
-
-    // Используем правильные имена параметров
-    await axios.post(
-      '/api/access/mint',
-      {
-        walletAddress,
-        role,
-        expiresInDays,
-      },
-      {
-        withCredentials: true,
-      }
-    );
-
-    await loadTokens();
-  } catch (error) {
-    console.error('Ошибка при выпуске токена:', error);
-    if (error.response) {
-      console.error('Статус ошибки:', error.response.status);
-      console.error('Данные ошибки:', error.response.data);
-    }
-  }
-}
-
-async function revokeToken(tokenId) {
-  try {
-    if (!confirm(`Вы уверены, что хотите отозвать токен #${tokenId}?`)) return;
-
-    await axios.post('/api/access/revoke', { tokenId });
-    await loadTokens();
-  } catch (error) {
-    console.error('Ошибка при отзыве токена:', error);
-  }
-}
-
-onMounted(async () => {
-  await loadTokens();
-});
-</script>
-
-<style scoped>
-.access-token-manager {
-  margin: 20px 0;
-}
-
-.token-actions {
-  margin: 15px 0;
-}
-
-.tokens-table {
-  width: 100%;
-  border-collapse: collapse;
-  margin-top: 15px;
-}
-
-.tokens-table th,
-.tokens-table td {
-  border: 1px solid #ddd;
-  padding: 8px;
-  text-align: left;
-}
-
-.tokens-table th {
-  background-color: #f2f2f2;
-}
-
-button {
-  margin-right: 5px;
-  padding: 5px 10px;
-  cursor: pointer;
-}
-</style>

frontend/src/components/Navigation.vue

@@ -1,33 +1,30 @@
 <template>
-  <nav class="main-nav">
+  <nav class="navbar">
-    <div class="nav-brand">
+    <div class="navbar-brand">
-      <router-link to="/">DApp for Business</router-link>
+      <router-link to="/" class="navbar-logo">DApp for Business</router-link>
     </div>
     
-    <div class="nav-links">
+    <div class="navbar-menu">
-      <router-link to="/" class="nav-link">Главная</router-link>
+      <div class="navbar-start">
-      <router-link to="/chat" class="nav-link">Чат</router-link>
+        <router-link to="/" class="navbar-item">Главная</router-link>
-      <router-link v-if="authStore.isAdmin" to="/admin" class="nav-link admin-link">
+        <router-link v-if="isAuthenticated" to="/chat" class="navbar-item">Чат</router-link>
-        Админ-панель
+      </div>
-      </router-link>
-    </div>
       
-    <div class="nav-auth">
+      <div class="navbar-end">
-      <template v-if="authStore.isAuthenticated">
+        <div v-if="isAuthenticated" class="navbar-item user-info">
-        <div class="user-info">
+          <span v-if="userAddress" class="user-address">{{ formatAddress(userAddress) }}</span>
-          <span class="user-address">{{ formatAddress(authStore.address) }}</span>
+          <button @click="logout" class="logout-btn">Выйти</button>
-          <span v-if="authStore.isAdmin" class="admin-badge">Админ</span>
         </div>
-        <button @click="logout" class="btn-logout">Выйти</button>
+        <div v-else class="navbar-item">
-      </template>
+          <WalletConnection />
-      <template v-else>
+        </div>
-        <wallet-connection />
+      </div>
-      </template>
     </div>
   </nav>
 </template>
 
 <script setup>
+import { computed } from 'vue';
 import { useRouter } from 'vue-router';
 import { useAuthStore } from '../stores/auth';
 import WalletConnection from './WalletConnection.vue';
@@ -35,10 +32,13 @@ import WalletConnection from './WalletConnection.vue';
 const router = useRouter();
 const authStore = useAuthStore();
 
+const isAuthenticated = computed(() => authStore.isAuthenticated);
+const userAddress = computed(() => authStore.user?.address);
+
 // Форматирование адреса кошелька
 function formatAddress(address) {
   if (!address) return '';
-  return address.substring(0, 6) + '...' + address.substring(address.length - 4);
+  return `${address.substring(0, 6)}...${address.substring(address.length - 4)}`;
 }
 
 // Выход из системы
@@ -49,85 +49,108 @@ async function logout() {
 </script>
 
 <style scoped>
-.main-nav {
+.navbar {
   display: flex;
   justify-content: space-between;
   align-items: center;
-  padding: 1rem;
+  padding: 0.5rem 1rem;
   background-color: #fff;
-  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
 }
 
-.nav-brand a {
+.navbar-brand {
+  font-weight: bold;
   font-size: 1.25rem;
-  font-weight: 700;
+}
-  color: #3498db;
+
+.navbar-logo {
+  color: #1976d2;
   text-decoration: none;
 }
 
-.nav-links {
+.navbar-menu {
   display: flex;
-  gap: 1rem;
+  justify-content: space-between;
+  flex: 1;
+  margin-left: 1rem;
 }
 
-.nav-link {
+.navbar-start, .navbar-end {
-  color: #333;
-  text-decoration: none;
-  padding: 0.5rem;
-  border-radius: 4px;
-}
-
-.nav-link:hover {
-  background-color: #f0f0f0;
-}
-
-.nav-link.router-link-active {
-  color: #3498db;
-  font-weight: 500;
-}
-
-.admin-link {
-  color: #e74c3c;
-}
-
-.nav-auth {
   display: flex;
   align-items: center;
-  gap: 1rem;
+}
+
+.navbar-item {
+  padding: 0.5rem 0.75rem;
+  color: #333;
+  text-decoration: none;
+  margin: 0 0.25rem;
+}
+
+.navbar-item:hover {
+  color: #1976d2;
 }
 
 .user-info {
   display: flex;
   align-items: center;
-  gap: 0.5rem;
 }
 
 .user-address {
   font-family: monospace;
-  background-color: #f0f0f0;
+  background-color: #f5f5f5;
   padding: 0.25rem 0.5rem;
   border-radius: 4px;
+  margin-right: 0.5rem;
 }
 
-.admin-badge {
+.logout-btn {
-  background-color: #e74c3c;
+  background-color: #f44336;
   color: white;
-  padding: 0.1rem 0.3rem;
-  border-radius: 4px;
-  font-size: 0.8rem;
-  font-weight: 500;
-}
-
-.btn-logout {
-  padding: 0.5rem 1rem;
-  border-radius: 4px;
-  background-color: #f0f0f0;
-  color: #333;
   border: none;
+  padding: 0.25rem 0.5rem;
+  border-radius: 4px;
   cursor: pointer;
+  font-size: 0.875rem;
 }
 
-.btn-logout:hover {
+.logout-btn:hover {
-  background-color: #e0e0e0;
+  background-color: #d32f2f;
+}
+
+@media (max-width: 768px) {
+  .navbar {
+    flex-direction: column;
+    padding: 0.5rem;
+  }
+  
+  .navbar-menu {
+    flex-direction: column;
+    width: 100%;
+    margin-left: 0;
+    margin-top: 0.5rem;
+  }
+  
+  .navbar-start, .navbar-end {
+    flex-direction: column;
+    width: 100%;
+  }
+  
+  .navbar-item {
+    padding: 0.5rem;
+    margin: 0.25rem 0;
+    width: 100%;
+    text-align: center;
+  }
+  
+  .user-info {
+    flex-direction: column;
+    align-items: center;
+  }
+  
+  .user-address {
+    margin-right: 0;
+    margin-bottom: 0.5rem;
+  }
 }
 </style>

frontend/src/components/WalletConnection.vue

@@ -4,47 +4,62 @@
       {{ error }}
     </div>
 
-    <button @click="connect" class="connect-button" :disabled="loading">
+    <button @click="connectWallet" class="connect-button" :disabled="loading">
       <div v-if="loading" class="spinner"></div>
       {{ loading ? 'Подключение...' : 'Подключить кошелек' }}
     </button>
   </div>
 </template>
 
-<script setup>
+<script>
 import { ref } from 'vue';
 import { connectWallet } from '../utils/wallet';
 import { useAuthStore } from '../stores/auth';
 import { useRouter } from 'vue-router';
 
-const authStore = useAuthStore();
+export default {
-const router = useRouter();
+  setup() {
-const loading = ref(false);
+    const authStore = useAuthStore();
-const error = ref('');
+    const router = useRouter();
+    const loading = ref(false);
+    const error = ref('');
 
-async function connect() {
+    return {
-  console.log('Нажата кнопка "Подключить кошелек"');
+      authStore,
-
+      router,
-  if (loading.value) return;
+      loading,
-
+      error
-  loading.value = true;
+    }
-  error.value = '';
+  },
-
+  methods: {
-  try {
+    async connectWallet() {
-    const authResult = await connectWallet();
+      console.log('Нажата кнопка "Подключить кошелек"');
-    console.log('Результат подключения:', authResult);
+
-    
+      if (this.loading) return;
-    if (authResult && authResult.authenticated) {
+
-      authStore.updateAuthState(authResult);
+      this.loading = true;
-      router.push({ name: 'home' });
+      this.error = '';
-    } else {
+
-      error.value = 'Не удалось подключить кошелек';
+      try {
+        const authResult = await connectWallet();
+        console.log('Результат подключения:', authResult);
+        
+        if (authResult && authResult.authenticated) {
+          this.authStore.isAuthenticated = authResult.authenticated;
+          this.authStore.user = { address: authResult.address };
+          this.authStore.isAdmin = authResult.isAdmin;
+          this.authStore.authType = authResult.authType;
+          this.router.push({ name: 'home' });
+        } else {
+          this.error = 'Не удалось подключить кошелек';
+        }
+      } catch (error) {
+        console.error('Ошибка при подключении кошелька:', error);
+        this.error = error.message || 'Ошибка при подключении кошелька';
+      } finally {
+        this.loading = false;
+      }
     }
-  } catch (error) {
-    console.error('Ошибка при подключении кошелька:', error);
-    error.value = error.message || 'Ошибка при подключении кошелька';
-  } finally {
-    loading.value = false;
   }
 }
 </script>

frontend/src/components/identity/EmailConnect.vue

@@ -0,0 +1,195 @@
+<template>
+  <div class="email-connect">
+    <p>Подключите свой email для быстрой авторизации.</p>
+    
+    <div class="email-form">
+      <input 
+        type="email" 
+        v-model="email" 
+        placeholder="Введите ваш email" 
+        :disabled="loading || verificationSent"
+      />
+      <button 
+        @click="sendVerification" 
+        class="connect-button"
+        :disabled="!isValidEmail || loading || verificationSent"
+      >
+        <span class="email-icon">✉️</span> {{ verificationSent ? 'Код отправлен' : 'Отправить код' }}
+      </button>
+    </div>
+    
+    <div v-if="verificationSent" class="verification-form">
+      <input 
+        type="text" 
+        v-model="verificationCode" 
+        placeholder="Введите код подтверждения" 
+        :disabled="loading"
+      />
+      <button 
+        @click="verifyEmail" 
+        class="verify-button"
+        :disabled="!verificationCode || loading"
+      >
+        Подтвердить
+      </button>
+    </div>
+    
+    <div v-if="loading" class="loading">Загрузка...</div>
+    <div v-if="error" class="error">{{ error }}</div>
+    <div v-if="success" class="success">{{ success }}</div>
+  </div>
+</template>
+
+<script setup>
+import { ref, computed } from 'vue';
+import axios from 'axios';
+
+const email = ref('');
+const verificationCode = ref('');
+const loading = ref(false);
+const error = ref('');
+const success = ref('');
+const verificationSent = ref(false);
+
+const isValidEmail = computed(() => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email.value);
+});
+
+async function sendVerification() {
+  if (!isValidEmail.value) return;
+  
+  try {
+    loading.value = true;
+    error.value = '';
+    success.value = '';
+    
+    // Запрос на отправку кода подтверждения
+    const response = await axios.post('/api/auth/email', {
+      email: email.value
+    }, {
+      withCredentials: true
+    });
+    
+    if (response.data.error) {
+      error.value = `Ошибка: ${response.data.error}`;
+      return;
+    }
+    
+    verificationSent.value = true;
+    success.value = `Код подтверждения отправлен на ${email.value}`;
+  } catch (err) {
+    console.error('Error sending verification code:', err);
+    error.value = 'Ошибка при отправке кода подтверждения';
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function verifyEmail() {
+  if (!verificationCode.value) return;
+  
+  try {
+    loading.value = true;
+    error.value = '';
+    success.value = '';
+    
+    // Запрос на проверку кода
+    const response = await axios.post('/api/auth/email/verify', {
+      email: email.value,
+      code: verificationCode.value
+    }, {
+      withCredentials: true
+    });
+    
+    if (response.data.error) {
+      error.value = `Ошибка: ${response.data.error}`;
+      return;
+    }
+    
+    success.value = 'Email успешно подтвержден';
+    
+    // Сбрасываем форму
+    setTimeout(() => {
+      email.value = '';
+      verificationCode.value = '';
+      verificationSent.value = false;
+      success.value = '';
+    }, 3000);
+  } catch (err) {
+    console.error('Error verifying email:', err);
+    error.value = 'Ошибка при проверке кода подтверждения';
+  } finally {
+    loading.value = false;
+  }
+}
+</script>
+
+<style scoped>
+.email-connect {
+  display: flex;
+  flex-direction: column;
+  gap: 15px;
+}
+
+.email-form, .verification-form {
+  display: flex;
+  gap: 10px;
+}
+
+input {
+  flex: 1;
+  padding: 10px;
+  border: 1px solid #ddd;
+  border-radius: 4px;
+  font-size: 16px;
+}
+
+.connect-button, .verify-button {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 10px 15px;
+  background-color: #4caf50;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 16px;
+  transition: background-color 0.2s;
+  white-space: nowrap;
+}
+
+.connect-button:hover, .verify-button:hover {
+  background-color: #45a049;
+}
+
+.connect-button:disabled, .verify-button:disabled {
+  background-color: #cccccc;
+  cursor: not-allowed;
+}
+
+.email-icon {
+  margin-right: 10px;
+  font-size: 18px;
+}
+
+.loading, .error, .success {
+  padding: 10px;
+  border-radius: 4px;
+}
+
+.loading {
+  background-color: #f8f9fa;
+}
+
+.error {
+  background-color: #f8d7da;
+  color: #721c24;
+}
+
+.success {
+  background-color: #d4edda;
+  color: #155724;
+}
+</style>

frontend/src/components/identity/IdentityManager.vue

@@ -0,0 +1,48 @@
+<script setup>
+import { ref, onMounted } from 'vue';
+import { useAuthStore } from '../../stores/auth';
+
+const authStore = useAuthStore();
+const identities = ref({});
+const newIdentity = ref({ type: 'email', value: '' });
+const loading = ref(false);
+const error = ref(null);
+
+onMounted(async () => {
+  try {
+    loading.value = true;
+    const response = await fetch('/api/access/tokens', {
+      credentials: 'include'
+    });
+    const data = await response.json();
+    identities.value = data.identities || {};
+  } catch (err) {
+    error.value = 'Ошибка при загрузке идентификаторов';
+    console.error(err);
+  } finally {
+    loading.value = false;
+  }
+});
+
+async function addIdentity() {
+  try {
+    loading.value = true;
+    error.value = null;
+    
+    const success = await authStore.linkIdentity(
+      newIdentity.value.type,
+      newIdentity.value.value
+    );
+    
+    if (success) {
+      identities.value = authStore.identities;
+      newIdentity.value.value = '';
+    }
+  } catch (err) {
+    error.value = 'Ошибка при добавлении идентификатора';
+    console.error(err);
+  } finally {
+    loading.value = false;
+  }
+}
+</script>

frontend/src/components/identity/TelegramConnect.vue

@@ -0,0 +1,102 @@
+<template>
+  <div class="telegram-connect">
+    <p>Подключите свой аккаунт Telegram для быстрой авторизации.</p>
+    <button @click="connectTelegram" class="connect-button">
+      <span class="telegram-icon">📱</span> Подключить Telegram
+    </button>
+    
+    <div v-if="loading" class="loading">Загрузка...</div>
+    <div v-if="error" class="error">{{ error }}</div>
+    <div v-if="success" class="success">{{ success }}</div>
+  </div>
+</template>
+
+<script setup>
+import { ref } from 'vue';
+import axios from 'axios';
+
+const loading = ref(false);
+const error = ref('');
+const success = ref('');
+
+async function connectTelegram() {
+  try {
+    loading.value = true;
+    error.value = '';
+    success.value = '';
+    
+    // Запрос на получение ссылки для авторизации через Telegram
+    const response = await axios.get('/api/auth/telegram', {
+      withCredentials: true
+    });
+    
+    if (response.data.error) {
+      error.value = `Ошибка при подключении Telegram: ${response.data.error}`;
+      return;
+    }
+    
+    if (response.data.authUrl) {
+      success.value = 'Перейдите по ссылке для авторизации через Telegram';
+      window.open(response.data.authUrl, '_blank');
+    } else {
+      error.value = 'Не удалось получить ссылку для авторизации';
+    }
+  } catch (err) {
+    console.error('Error connecting Telegram:', err);
+    error.value = 'Ошибка при подключении Telegram';
+  } finally {
+    loading.value = false;
+  }
+}
+</script>
+
+<style scoped>
+.telegram-connect {
+  display: flex;
+  flex-direction: column;
+  gap: 15px;
+}
+
+.connect-button {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 10px 15px;
+  background-color: #0088cc;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 16px;
+  transition: background-color 0.2s;
+}
+
+.connect-button:hover {
+  background-color: #0077b5;
+}
+
+.telegram-icon {
+  margin-right: 10px;
+  font-size: 18px;
+}
+
+.loading, .error, .success {
+  padding: 10px;
+  border-radius: 4px;
+}
+
+.loading {
+  background-color: #f8f9fa;
+}
+
+.error {
+  background-color: #f8d7da;
+  color: #721c24;
+}
+
+.success {
+  background-color: #d4edda;
+  color: #155724;
+}
+</style>
+

frontend/src/composables/useEthereum.js

@@ -1,17 +1,50 @@
 import { ref } from 'vue';
+import { ethers } from 'ethers';
 
 export function useEthereum() {
   const address = ref('');
-  const isConnected = ref(true);
+  const isConnected = ref(false);
+  const provider = ref(null);
+  const signer = ref(null);
 
   async function connect() {
-    console.log('Имитация подключения к кошельку');
+    if (window.ethereum) {
-    return { success: true };
+      try {
+        // Запрашиваем доступ к кошельку
+        await window.ethereum.request({ method: 'eth_requestAccounts' });
+        // Используем синтаксис ethers.js v6
+        provider.value = new ethers.BrowserProvider(window.ethereum);
+        signer.value = await provider.value.getSigner();
+        address.value = await signer.value.getAddress();
+        isConnected.value = true;
+        
+        console.log('Подключение успешно:', address.value);
+        return { success: true, address: address.value };
+      } catch (error) {
+        console.error('Ошибка подключения к кошельку:', error);
+        return { success: false, error: error.message };
+      }
+    } else {
+      console.error('Ethereum wallet not found. Please install MetaMask.');
+      return { success: false, error: 'Ethereum wallet not found. Please install MetaMask.' };
+    }
   }
 
-  async function getContract() {
+  async function getContract(contractAddress, contractABI) {
-    console.log('Имитация получения контракта');
+    if (!signer.value) {
-    return {};
+      console.error('Подключите кошелек перед получением контракта.');
+      return null;
+    }
+
+    try {
+      // Используем синтаксис ethers.js v6
+      const contract = new ethers.Contract(contractAddress, contractABI, signer.value);
+      console.log('Контракт получен:', contract);
+      return contract;
+    } catch (error) {
+      console.error('Ошибка получения контракта:', error);
+      return null;
+    }
   }
 
   return {

frontend/src/main.js

@@ -8,7 +8,7 @@ import router from './router';
 import axios from 'axios';
 
 // Настройка axios
-axios.defaults.baseURL = 'http://localhost:8000';
+axios.defaults.baseURL = ''; // Пустой baseURL, так как мы используем прокси
 axios.defaults.withCredentials = true; // Важно для работы с сессиями
 
 // Создаем и монтируем приложение Vue

frontend/src/router/index.js

@@ -1,12 +1,7 @@
 import { createRouter, createWebHistory } from 'vue-router';
 import { useAuthStore } from '../stores/auth';
-// Импортируем компоненты напрямую, если они существуют
 import HomeView from '../views/HomeView.vue';
-import DashboardView from '../views/DashboardView.vue';
+import ChatView from '../views/ChatView.vue';
-import ProfileView from '../views/ProfileView.vue';
-import AdminView from '../views/AdminView.vue'; // Новый компонент для администраторов
-import AccessTestView from '../views/AccessTestView.vue';
-import ConversationsView from '../views/ConversationsView.vue';
 
 const routes = [
   {
@@ -15,41 +10,12 @@ const routes = [
     component: HomeView,
     meta: { requiresAuth: false },
   },
-  {
-    path: '/dashboard',
-    name: 'Dashboard',
-    component: () => import('../views/DashboardView.vue'),
-    meta: { requiresAuth: true, requiresAdmin: true },
-  },
-  // Перенаправляем с /chat на главную страницу
   {
     path: '/chat',
-    redirect: { name: 'home' },
+    name: 'chat',
-  },
+    component: ChatView,
-  {
+    meta: { requiresAuth: true }
-    path: '/profile',
+  }
-    name: 'profile',
-    component: ProfileView,
-    meta: { requiresAuth: true },
-  },
-  {
-    path: '/admin',
-    name: 'Admin',
-    component: () => import('../views/AdminView.vue'),
-    meta: { requiresAdmin: true },
-  },
-  {
-    path: '/access-test',
-    name: 'access-test',
-    component: AccessTestView,
-    meta: { requiresAuth: true, requiresAdmin: true },
-  },
-  {
-    path: '/conversations',
-    name: 'Conversations',
-    component: ConversationsView,
-    meta: { requiresAuth: true },
-  },
 ];
 
 const router = createRouter({
@@ -64,20 +30,18 @@ const router = createRouter({
 router.beforeEach(async (to, from, next) => {
   const authStore = useAuthStore();
   
-  // Проверяем аутентификацию только если еще не проверяли
+  // Проверяем аутентификацию, если она еще не проверена
-  if (!authStore.checkPerformed) {
+  if (!authStore.isAuthenticated) {
     try {
       await authStore.checkAuth();
     } catch (error) {
-      console.error('Ошибка при проверке аутентификации:', error);
+      console.error('Error checking auth:', error);
     }
   }
   
   // Проверка прав доступа
   if (to.meta.requiresAuth && !authStore.isAuthenticated) {
-    next({ name: 'Home' });
+    next({ name: 'home' });
-  } else if (to.meta.requiresAdmin && !authStore.isAdmin) {
-    next({ name: 'Home' });
   } else {
     next();
   }

frontend/src/stores/auth.js

@@ -1,85 +1,153 @@
 import { defineStore } from 'pinia';
-import { ref } from 'vue';
+import axios from '../api/axios';
-import axios from 'axios';
 
-export const useAuthStore = defineStore('auth', () => {
+export const useAuthStore = defineStore('auth', {
-  const isAuthenticated = ref(false);
+  state: () => ({
-  const isAdmin = ref(false);
+    user: null,
-  const address = ref(null);
+    isAuthenticated: false,
-  const authType = ref(null);
+    isAdmin: false,
-  const loading = ref(false);
+    authType: null,
-  const checkPerformed = ref(false);
+    identities: {},
+    loading: false,
+    error: null
+  }),
   
-  // Проверка аутентификации
+  actions: {
-  async function checkAuth() {
+    async connectWallet(address, signature, message) {
-    loading.value = true;
+      this.loading = true;
+      this.error = null;
       
-    try {
+      try {
-      console.log('Проверка аутентификации...');
+        const response = await axios.post('/api/auth/verify', {
-      const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
+          address, 
-      console.log('API URL:', apiUrl);
+          signature, 
+          message
+        });
         
-      const response = await axios.get(`${apiUrl}/api/auth/check`, {
+        this.user = {
-        withCredentials: true,
+          id: response.data.userId,
-      });
+          address
+        };
+        this.isAuthenticated = response.data.authenticated;
+        this.isAdmin = response.data.isAdmin;
+        this.authType = response.data.authType;
+        this.identities = response.data.identities || {};
         
-      console.log('Статус аутентификации:', response.data.authenticated);
+        return true;
-      console.log('Статус администратора:', response.data.isAdmin);
+      } catch (error) {
+        this.error = error.response?.data?.error || 'Ошибка подключения кошелька';
+        return false;
+      } finally {
+        this.loading = false;
+      }
+    },
     
-      isAuthenticated.value = response.data.authenticated;
+    async connectTelegram(telegramData) {
-      isAdmin.value = response.data.isAdmin;
+      this.loading = true;
-      address.value = response.data.address;
+      this.error = null;
-      authType.value = response.data.authType;
-    } catch (error) {
-      console.error('Ошибка при проверке аутентификации:', error);
-      throw error;
-    } finally {
-      loading.value = false;
-      checkPerformed.value = true;
-    }
-  }
       
-  // Обновление состояния аутентификации
+      try {
-  function updateAuthState(authData) {
+        const response = await axios.post('/api/auth/telegram', telegramData);
-    console.log('Обновление состояния аутентификации:', authData);
         
-    isAuthenticated.value = authData.authenticated || false;
+        this.user = {
-    isAdmin.value = authData.isAdmin || false;
+          id: response.data.userId,
-    address.value = authData.address || null;
+          telegramId: telegramData.telegramId
-    authType.value = authData.authType || null;
+        };
-    checkPerformed.value = true;
+        this.isAuthenticated = response.data.authenticated;
-  }
+        this.isAdmin = response.data.isAdmin;
+        this.authType = response.data.authType;
+        this.identities = response.data.identities || {};
         
-  // Выход из системы
+        return true;
-  async function logout() {
+      } catch (error) {
-    try {
+        this.error = error.response?.data?.error || 'Ошибка подключения Telegram';
-      await axios.post(
+        return false;
-        `${import.meta.env.VITE_API_URL}/api/auth/logout`,
+      } finally {
-        {},
+        this.loading = false;
-        {
+      }
-          withCredentials: true,
+    },
+    
+    async connectEmail(email, verificationCode) {
+      this.loading = true;
+      this.error = null;
+      
+      try {
+        const response = await axios.post('/api/auth/email', {
+          email, verificationCode
+        });
+        
+        this.user = {
+          id: response.data.userId,
+          email
+        };
+        this.isAuthenticated = response.data.authenticated;
+        this.isAdmin = response.data.isAdmin;
+        this.authType = response.data.authType;
+        this.identities = response.data.identities || {};
+        
+        return true;
+      } catch (error) {
+        this.error = error.response?.data?.error || 'Ошибка подключения Email';
+        return false;
+      } finally {
+        this.loading = false;
+      }
+    },
+    
+    async linkIdentity(identityType, identityValue) {
+      this.loading = true;
+      this.error = null;
+      
+      try {
+        const response = await axios.post('/api/auth/link-identity', {
+          identityType, identityValue
+        });
+        
+        this.identities = response.data.identities;
+        this.isAdmin = response.data.isAdmin;
+        
+        return true;
+      } catch (error) {
+        this.error = error.response?.data?.error || 'Ошибка связывания аккаунта';
+        return false;
+      } finally {
+        this.loading = false;
+      }
+    },
+    
+    async logout() {
+      try {
+        await axios.post('/api/auth/logout');
+      } catch (error) {
+        console.error('Ошибка при выходе:', error);
+      }
+      
+      this.user = null;
+      this.isAuthenticated = false;
+      this.isAdmin = false;
+      this.authType = null;
+      this.identities = {};
+    },
+    
+    async checkAuth() {
+      try {
+        const response = await axios.get('/api/auth/check');
+        
+        if (response.data.authenticated) {
+          this.user = {
+            id: response.data.userId
+          };
+          this.isAuthenticated = true;
+          this.isAdmin = response.data.isAdmin;
+          this.authType = response.data.authType;
+          this.identities = response.data.identities || {};
+        } else {
+          this.logout();
         }
-      );
+      } catch (error) {
-    } catch (error) {
+        console.error('Ошибка при проверке аутентификации:', error);
-      console.error('Ошибка при выходе из системы:', error);
+        this.logout();
-    } finally {
+      }
-      // Сбрасываем состояние независимо от результата запроса
-      isAuthenticated.value = false;
-      isAdmin.value = false;
-      address.value = null;
-      authType.value = null;
     }
   }
-
-  return {
-    isAuthenticated,
-    isAdmin,
-    address,
-    authType,
-    loading,
-    checkPerformed,
-    checkAuth,
-    updateAuthState,
-    logout,
-  };
 });

frontend/src/utils/wallet.js

@@ -1,105 +1,50 @@
 import axios from 'axios';
 
 async function connectWallet() {
-  console.log('Начинаем подключение кошелька...');
+  if (typeof window.ethereum !== 'undefined') {
-
-  try {
-    // Проверяем доступность MetaMask
-    if (typeof window.ethereum === 'undefined') {
-      throw new Error('MetaMask не установлен');
-    }
-
-    console.log('MetaMask доступен, запрашиваем аккаунты...');
-
-    // Запрашиваем доступ к аккаунтам
-    const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
-    const address = accounts[0];
-
-    if (!address) {
-      throw new Error('Не удалось получить адрес кошелька');
-    }
-
-    console.log('Получен адрес кошелька:', address);
-
-    const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
-    console.log('API URL для nonce:', apiUrl);
-
-    // Получаем nonce для подписи
-    let nonce;
-    
-    // Пробуем прямой запрос к серверу
     try {
-      const directNonceResponse = await axios.get(
+      const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
-        `${apiUrl}/api/auth/nonce?address=${address}`,
+      const address = accounts[0];
-        {
-          withCredentials: true,
-        }
-      );
 
-      console.log('Прямой ответ сервера:', directNonceResponse.data);
+      // Получаем nonce
-      console.log('Cookies after direct request:', document.cookie);
+      const nonceResponse = await axios.get(`/api/auth/nonce?address=${address}`, {
+        withCredentials: true // Важно для сохранения сессии
+      });
+      const nonce = nonceResponse.data.nonce;
 
-      nonce = directNonceResponse.data.nonce;
+      // Подписываем сообщение
-    } catch (error) {
+      const message = `Sign this message to authenticate with our app: ${nonce}`;
-      console.error('Ошибка при получении nonce:', error);
-      throw new Error('Не удалось получить nonce для подписи');
-    }
-
-    console.log('Получен nonce:', nonce);
-
-    // Создаем сообщение для подписи
-    const message = `Подтвердите вход в DApp for Business с nonce: ${nonce}`;
-
-    try {
-      // Запрашиваем подпись используя ethereum.request
       const signature = await window.ethereum.request({
         method: 'personal_sign',
-        params: [message, address],
+        params: [message, address]
       });
 
-      console.log('Получена подпись:', signature);
+      // Отправляем запрос на проверку
-
+      const verifyResponse = await axios.post('/api/auth/verify', {
-      // Отправляем подпись на сервер
-      const verifyResponse = await axios.post(
-        `${apiUrl}/api/auth/verify`,
-        {
-          address,
-          signature,
-          message,
-          nonce,
-        },
-        {
-          headers: {
-            'X-Auth-Nonce': nonce,
-          },
-          withCredentials: true,
-        }
-      );
-
-      console.log('Ответ сервера:', verifyResponse.data);
-
-      // Сохраняем адрес в localStorage для восстановления сессии
-      localStorage.setItem('walletAddress', address);
-
-      // Возвращаем данные аутентификации
-      return {
         address,
+        signature,
+        message
+      }, {
+        withCredentials: true // Важно для сохранения сессии
+      });
+      
+      console.log('Успешно подключен:', verifyResponse.data);
+      
+      // Возвращаем результат подключения
+      return {
+        success: true,
         authenticated: verifyResponse.data.authenticated,
+        address: address,
         isAdmin: verifyResponse.data.isAdmin,
-        authType: 'wallet',
+        authType: 'wallet'
       };
-    } catch (signError) {
+    } catch (error) {
-      console.error('Ошибка при подписи сообщения:', signError);
+      console.error('Ошибка при подключении кошелька:', error);
-
+      return { success: false, error: error.message };
-      if (signError.code === 4001) {
-        throw new Error('Пользователь отклонил запрос на подпись');
-      }
-
-      throw new Error('Не удалось подписать сообщение');
     }
-  } catch (error) {
+  } else {
-    console.error('Ошибка при подключении кошелька:', error);
+    console.error('MetaMask не установлен');
-    throw error;
+    return { success: false, error: 'MetaMask не установлен' };
   }
 }
 
@@ -114,9 +59,6 @@ async function disconnectWallet() {
       }
     );
 
-    // Удаляем адрес из localStorage
-    localStorage.removeItem('walletAddress');
-
     return { success: true };
   } catch (error) {
     console.error('Ошибка при отключении кошелька:', error);

frontend/src/views/AccessTestView.vue

@@ -1,27 +0,0 @@
-<template>
-  <div class="access-test-view">
-    <h1>Тестирование доступа</h1>
-    <p>Эта страница предназначена для тестирования смарт-контрактов и управления доступом.</p>
-
-    <div class="access-test-container">
-      <AccessControl />
-    </div>
-  </div>
-</template>
-
-<script setup>
-import AccessControl from '../components/AccessControl.vue';
-</script>
-
-<style scoped>
-.access-test-view {
-  padding: 20px;
-}
-
-.access-test-container {
-  margin-top: 20px;
-  padding: 15px;
-  background-color: #f5f5f5;
-  border-radius: 4px;
-}
-</style>

frontend/src/views/AdminView.vue

@@ -1,279 +0,0 @@
-<template>
-  <div class="admin-view">
-    <h1>Панель администратора</h1>
-
-    <div v-if="!authStore.isAdmin" class="admin-error">
-      <p>У вас нет прав администратора для доступа к этой странице.</p>
-      <button @click="updateAdminStatus" class="btn btn-primary">
-        Получить права администратора
-      </button>
-    </div>
-
-    <div v-else-if="loading" class="loading">Загрузка данных администратора...</div>
-
-    <div v-else-if="error" class="error-message">
-      {{ error }}
-    </div>
-
-    <div v-else class="admin-content">
-      <div class="admin-section">
-        <h2>Статистика</h2>
-        <div class="stats-grid">
-          <div class="stat-card">
-            <h3>Пользователи</h3>
-            <p class="stat-value">{{ stats.userCount || 0 }}</p>
-          </div>
-          <div class="stat-card">
-            <h3>Доски</h3>
-            <p class="stat-value">{{ stats.boardCount || 0 }}</p>
-          </div>
-          <div class="stat-card">
-            <h3>Задачи</h3>
-            <p class="stat-value">{{ stats.taskCount || 0 }}</p>
-          </div>
-        </div>
-      </div>
-
-      <div class="admin-section">
-        <h2>Пользователи</h2>
-        <table class="users-table">
-          <thead>
-            <tr>
-              <th>ID</th>
-              <th>Адрес</th>
-              <th>Администратор</th>
-              <th>Создан</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr v-for="user in users" :key="user.id">
-              <td>{{ user.id }}</td>
-              <td>{{ user.address }}</td>
-              <td>{{ user.is_admin ? 'Да' : 'Нет' }}</td>
-              <td>{{ new Date(user.created_at).toLocaleString() }}</td>
-            </tr>
-          </tbody>
-        </table>
-      </div>
-
-      <div class="admin-section">
-        <h2>Логи</h2>
-        <table class="logs-table">
-          <thead>
-            <tr>
-              <th>ID</th>
-              <th>Тип</th>
-              <th>Сообщение</th>
-              <th>Время</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr v-for="log in logs" :key="log.id">
-              <td>{{ log.id }}</td>
-              <td>{{ log.type }}</td>
-              <td>{{ log.message }}</td>
-              <td>{{ new Date(log.created_at).toLocaleString() }}</td>
-            </tr>
-          </tbody>
-        </table>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { ref, onMounted } from 'vue';
-import { useAuthStore } from '../stores/auth';
-import axios from 'axios';
-
-const authStore = useAuthStore();
-const users = ref([]);
-const stats = ref({});
-const logs = ref([]);
-const loading = ref(true);
-const error = ref(null);
-
-// Функция для обновления статуса администратора
-async function updateAdminStatus() {
-  try {
-    const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
-
-    console.log('Обновление статуса администратора для адреса:', authStore.address);
-
-    // Отправляем запрос на обновление статуса администратора
-    const response = await axios.post(
-      `${apiUrl}/api/auth/update-admin-status`,
-      {
-        address: authStore.address,
-        isAdmin: true,
-      },
-      {
-        withCredentials: true,
-      }
-    );
-
-    console.log('Статус администратора обновлен:', response.data);
-
-    // Обновляем сессию
-    const refreshResponse = await axios.post(
-      `${apiUrl}/api/auth/refresh-session`,
-      {
-        address: authStore.address,
-      },
-      {
-        withCredentials: true,
-      }
-    );
-
-    console.log('Сессия обновлена после обновления статуса:', refreshResponse.data);
-
-    // Обновляем статус администратора в хранилище
-    authStore.updateAuthState({
-      ...authStore.$state,
-      isAdmin: refreshResponse.data.isAdmin,
-    });
-
-    // Перезагружаем страницу
-    window.location.reload();
-  } catch (error) {
-    console.error('Ошибка при обновлении статуса администратора:', error);
-
-    if (error.response) {
-      console.error('Статус ответа:', error.response.status);
-      console.error('Данные ответа:', error.response.data);
-    }
-  }
-}
-
-// Загрузка данных администратора
-async function loadAdminData() {
-  try {
-    loading.value = true;
-    error.value = null;
-
-    const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
-
-    // Заголовки для запросов
-    const headers = {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${authStore.address}`,
-    };
-
-    console.log('Запрос к API администратора с заголовками:', headers);
-
-    // Загрузка пользователей
-    const usersResponse = await axios.get(`${apiUrl}/api/admin/users`, {
-      withCredentials: true,
-      headers,
-    });
-
-    users.value = usersResponse.data;
-
-    // Загрузка статистики
-    const statsResponse = await axios.get(`${apiUrl}/api/admin/stats`, {
-      withCredentials: true,
-      headers,
-    });
-
-    stats.value = statsResponse.data;
-
-    // Загрузка логов
-    const logsResponse = await axios.get(`${apiUrl}/api/admin/logs`, {
-      withCredentials: true,
-      headers,
-    });
-
-    logs.value = logsResponse.data;
-
-    loading.value = false;
-  } catch (error) {
-    console.error('Ошибка при загрузке данных администратора:', error);
-
-    if (error.response) {
-      console.error('Статус ответа:', error.response.status);
-      console.error('Данные ответа:', error.response.data);
-      console.error('Заголовки ответа:', error.response.headers);
-    }
-
-    error.value = 'Ошибка при загрузке данных администратора';
-    loading.value = false;
-  }
-}
-
-onMounted(async () => {
-  if (authStore.isAdmin) {
-    await loadAdminData();
-  }
-});
-</script>
-
-<style scoped>
-.admin-view {
-  padding: 1rem;
-}
-
-.admin-error {
-  text-align: center;
-  padding: 2rem;
-  background-color: #f8d7da;
-  border-radius: 8px;
-  margin-bottom: 1rem;
-}
-
-.admin-section {
-  background-color: white;
-  border-radius: 8px;
-  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
-  padding: 1.5rem;
-  margin-bottom: 2rem;
-}
-
-.stats-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
-  gap: 1rem;
-}
-
-.stat-card {
-  background-color: #f8f9fa;
-  border-radius: 8px;
-  padding: 1rem;
-  text-align: center;
-}
-
-.stat-value {
-  font-size: 2rem;
-  font-weight: bold;
-  color: #3498db;
-}
-
-table {
-  width: 100%;
-  border-collapse: collapse;
-}
-
-th,
-td {
-  padding: 0.75rem;
-  text-align: left;
-  border-bottom: 1px solid #e9ecef;
-}
-
-th {
-  background-color: #f8f9fa;
-  font-weight: bold;
-}
-
-.loading,
-.error-message {
-  text-align: center;
-  padding: 2rem;
-  background-color: white;
-  border-radius: 8px;
-  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
-}
-
-.error-message {
-  color: #e74c3c;
-}
-</style>

frontend/src/views/ChatView.vue

@@ -1,282 +1,243 @@
 <template>
-  <div class="chat-container">
+  <div class="chat-view">
-    <ConversationList @select-conversation="handleSelectConversation" ref="conversationList" />
+    <div class="chat-container">
-
+      <h2>Чат с ИИ-ассистентом</h2>
-    <div class="chat-main">
+      <div class="chat-messages" ref="chatMessages">
-      <div v-if="!selectedConversationId" class="no-conversation">
+        <div
-        <p>Выберите диалог из списка или создайте новый, чтобы начать общение.</p>
+          v-for="(message, index) in messages"
-      </div>
+          :key="index"
-
+          :class="['message', message.sender === 'user' ? 'user-message' : 'ai-message']"
-      <template v-else>
+        >
-        <div class="chat-header">
+          <div class="message-content" v-html="message.text"></div>
-          <h2>{{ currentConversationTitle }}</h2>
+          <div class="message-time">{{ formatTime(message.timestamp) }}</div>
-          <div class="chat-actions">
-            <button @click="showRenameDialog = true" class="action-button">Переименовать</button>
-            <button @click="confirmDelete" class="action-button delete">Удалить</button>
-          </div>
-        </div>
-
-        <MessageThread :conversation-id="selectedConversationId" ref="messageThread" />
-
-        <MessageInput
-          :conversation-id="selectedConversationId"
-          @message-sent="handleMessageSent"
-          ref="messageInput"
-        />
-      </template>
-    </div>
-
-    <!-- Диалог переименования -->
-    <div v-if="showRenameDialog" class="dialog-overlay">
-      <div class="dialog">
-        <h3>Переименовать диалог</h3>
-        <input
-          v-model="newTitle"
-          placeholder="Введите новое название"
-          @keydown.enter="renameConversation"
-        />
-        <div class="dialog-actions">
-          <button @click="showRenameDialog = false" class="cancel-button">Отмена</button>
-          <button @click="renameConversation" class="confirm-button">Сохранить</button>
         </div>
       </div>
-    </div>
 
-    <!-- Диалог подтверждения удаления -->
+      <div class="chat-input">
-    <div v-if="showDeleteDialog" class="dialog-overlay">
+        <textarea
-      <div class="dialog">
+          v-model="userInput"
-        <h3>Удалить диалог?</h3>
+          placeholder="Введите ваше сообщение..."
-        <p>Вы уверены, что хотите удалить этот диалог? Это действие нельзя отменить.</p>
+          @keydown.enter.prevent="sendMessage"
-        <div class="dialog-actions">
+        ></textarea>
-          <button @click="showDeleteDialog = false" class="cancel-button">Отмена</button>
+        <button class="send-btn" @click="sendMessage" :disabled="!userInput.trim() || isLoading">
-          <button @click="deleteConversation" class="delete-button">Удалить</button>
+          {{ isLoading ? 'Отправка...' : 'Отправить' }}
-        </div>
+        </button>
       </div>
     </div>
   </div>
 </template>
 
 <script setup>
-import { ref, computed, nextTick } from 'vue';
+import { ref, onMounted, watch, nextTick } from 'vue';
-import ConversationList from '../components/chat/ConversationList.vue';
-import MessageThread from '../components/chat/MessageThread.vue';
-import MessageInput from '../components/chat/MessageInput.vue';
 import axios from 'axios';
+import { useAuthStore } from '../stores/auth';
 
-const selectedConversationId = ref(null);
+const userInput = ref('');
-const currentConversationTitle = ref('');
+const messages = ref([
-const conversationList = ref(null);
+  {
-const messageThread = ref(null);
+    sender: 'ai',
-const messageInput = ref(null);
+    text: 'Привет! Я ИИ-ассистент DApp for Business. Чем я могу помочь вам сегодня?',
+    timestamp: new Date(),
+  },
+]);
+const chatMessages = ref(null);
+const isLoading = ref(false);
+const authStore = useAuthStore();
 
-// Диалоги
+// Прокрутка чата вниз при добавлении новых сообщений
-const showRenameDialog = ref(false);
+watch(
-const showDeleteDialog = ref(false);
+  messages,
-const newTitle = ref('');
+  () => {
+    nextTick(() => {
+      if (chatMessages.value) {
+        chatMessages.value.scrollTop = chatMessages.value.scrollHeight;
+      }
+    });
+  },
+  { deep: true }
+);
 
-// Обработка выбора диалога
+// Проверка прав администратора
-const handleSelectConversation = (conversationId) => {
+onMounted(async () => {
-  selectedConversationId.value = conversationId;
+  if (authStore.isAdmin) {
-
+    messages.value.push({
-  // Получение заголовка диалога
+      sender: 'ai',
-  const conversation = conversationList.value.conversations.value.find(
+      text: 'Вы имеете права администратора.',
-    (c) => c.conversation_id === conversationId
+      timestamp: new Date(),
-  );
+    });
-
+  } else {
-  if (conversation) {
+    messages.value.push({
-    currentConversationTitle.value = conversation.title;
+      sender: 'ai',
+      text: 'У вас нет прав администратора.',
+      timestamp: new Date(),
+    });
   }
+});
 
-  // Фокус на поле ввода после загрузки сообщений
+// Функция для отправки сообщения
-  nextTick(() => {
+async function sendMessage() {
-    messageInput.value?.focus();
+  if (!userInput.value.trim() || isLoading.value) return;
+
+  // Добавляем сообщение пользователя в чат
+  const userMessage = userInput.value.trim();
+  messages.value.push({
+    sender: 'user',
+    text: userMessage,
+    timestamp: new Date(),
   });
-};
 
-// Обработка отправки сообщения
+  userInput.value = '';
-const handleMessageSent = (messages) => {
+  isLoading.value = true;
-  messageThread.value.addMessages(messages);
-};
-
-// Переименование диалога
-const renameConversation = async () => {
-  if (!newTitle.value.trim()) return;
 
   try {
-    const response = await axios.put(
+    console.log('Отправка сообщения:', userMessage);
-      `/api/messages/conversations/${selectedConversationId.value}`,
+    
-      { title: newTitle.value }
+    // Отправляем запрос к API
+    const response = await axios.post(
+      '/api/chat/message',
+      {
+        message: userMessage,
+        language: 'ru', // Укажите язык, если необходимо
+      },
+      {
+        withCredentials: true, // Важно для передачи куков
+      }
     );
 
-    // Обновление заголовка
+    console.log('Ответ от сервера:', response.data);
-    currentConversationTitle.value = response.data.title;
 
-    // Обновление списка диалогов
+    // Добавляем ответ от ИИ в чат
-    conversationList.value.fetchConversations();
+    messages.value.push({
-
+      sender: 'ai',
-    // Закрытие диалога
+      text: response.data.reply || 'Извините, я не смог обработать ваш запрос.',
-    showRenameDialog.value = false;
+      timestamp: new Date(),
-    newTitle.value = '';
+    });
   } catch (error) {
-    console.error('Error renaming conversation:', error);
+    console.error('Error sending message:', error);
+    messages.value.push({
+      sender: 'ai',
+      text: 'Извините, произошла ошибка при обработке вашего запроса. Пожалуйста, попробуйте позже.',
+      timestamp: new Date(),
+    });
+  } finally {
+    isLoading.value = false;
   }
-};
+}
 
-// Подтверждение удаления
+// Функция для форматирования времени
-const confirmDelete = () => {
+function formatTime(timestamp) {
-  showDeleteDialog.value = true;
+  if (!timestamp) return '';
-};
 
-// Удаление диалога
+  const date = new Date(timestamp);
-const deleteConversation = async () => {
+  return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-  try {
+}
-    await axios.delete(`/api/messages/conversations/${selectedConversationId.value}`);
-
-    // Обновление списка диалогов
-    conversationList.value.fetchConversations();
-
-    // Сброс выбранного диалога
-    selectedConversationId.value = null;
-    currentConversationTitle.value = '';
-
-    // Закрытие диалога
-    showDeleteDialog.value = false;
-  } catch (error) {
-    console.error('Error deleting conversation:', error);
-  }
-};
 </script>
 
 <style scoped>
-.chat-container {
+.chat-view {
+  height: 100%;
   display: flex;
-  height: calc(100vh - 64px); /* Высота экрана минус высота шапки */
+  flex-direction: column;
-  position: relative;
+  padding: 1rem;
 }
 
-.chat-main {
+.chat-container {
   flex: 1;
   display: flex;
   flex-direction: column;
-  background-color: #fff;
+  background-color: white;
-}
-
-.no-conversation {
-  flex: 1;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  color: #666;
-  padding: 2rem;
-  text-align: center;
-}
-
-.chat-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  padding: 1rem;
-  border-bottom: 1px solid #e0e0e0;
-  background-color: #f9f9f9;
-}
-
-.chat-header h2 {
-  margin: 0;
-  font-size: 1.2rem;
-  font-weight: 500;
-}
-
-.chat-actions {
-  display: flex;
-  gap: 0.5rem;
-}
-
-.action-button {
-  padding: 0.5rem 0.75rem;
-  background-color: #f0f0f0;
-  border: none;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 0.9rem;
-  transition: background-color 0.2s;
-}
-
-.action-button:hover {
-  background-color: #e0e0e0;
-}
-
-.action-button.delete {
-  color: #f44336;
-}
-
-.action-button.delete:hover {
-  background-color: #ffebee;
-}
-
-/* Стили для диалогов */
-.dialog-overlay {
-  position: fixed;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  background-color: rgba(0, 0, 0, 0.5);
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  z-index: 1000;
-}
-
-.dialog {
-  background-color: #fff;
   border-radius: 8px;
-  padding: 1.5rem;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
-  width: 400px;
+  overflow: hidden;
-  max-width: 90%;
+  max-width: 800px;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  margin: 0 auto;
-}
-
-.dialog h3 {
-  margin-top: 0;
-  margin-bottom: 1rem;
-}
-
-.dialog input {
   width: 100%;
+}
+
+h2 {
+  padding: 1rem;
+  margin: 0;
+  border-bottom: 1px solid #eee;
+  font-size: 1.5rem;
+  color: #333;
+}
+
+.chat-messages {
+  flex: 1;
+  overflow-y: auto;
+  padding: 1rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  min-height: 400px;
+}
+
+.message {
+  max-width: 80%;
+  padding: 0.75rem 1rem;
+  border-radius: 8px;
+  position: relative;
+}
+
+.user-message {
+  align-self: flex-end;
+  background-color: #e3f2fd;
+  color: #0d47a1;
+}
+
+.ai-message {
+  align-self: flex-start;
+  background-color: #f5f5f5;
+  color: #333;
+}
+
+.message-content {
+  word-break: break-word;
+}
+
+.message-time {
+  font-size: 0.75rem;
+  color: #999;
+  margin-top: 0.25rem;
+  text-align: right;
+}
+
+.chat-input {
+  display: flex;
+  padding: 1rem;
+  border-top: 1px solid #eee;
+  background-color: white;
+}
+
+textarea {
+  flex: 1;
   padding: 0.75rem;
-  border: 1px solid #e0e0e0;
+  border: 1px solid #ddd;
   border-radius: 4px;
-  margin-bottom: 1rem;
+  resize: none;
+  height: 60px;
+  font-family: inherit;
   font-size: 1rem;
 }
 
-.dialog-actions {
+.send-btn {
-  display: flex;
+  margin-left: 0.5rem;
-  justify-content: flex-end;
+  padding: 0 1.5rem;
-  gap: 0.75rem;
+  background-color: #1976d2;
-}
+  color: white;
-
-.cancel-button,
-.confirm-button,
-.delete-button {
-  padding: 0.5rem 1rem;
   border: none;
   border-radius: 4px;
   cursor: pointer;
-  font-weight: 500;
+  font-size: 1rem;
+  transition: background-color 0.2s;
 }
 
-.cancel-button {
+.send-btn:hover {
-  background-color: #f0f0f0;
+  background-color: #1565c0;
 }
 
-.confirm-button {
+.send-btn:disabled {
-  background-color: #4caf50;
+  background-color: #ccc;
-  color: white;
+  cursor: not-allowed;
-}
-
-.delete-button {
-  background-color: #f44336;
-  color: white;
 }
 </style>

frontend/src/views/DashboardView.vue

@@ -1,27 +0,0 @@
-<template>
-  <div class="dashboard-view">
-    <h1>Дашборд</h1>
-    <p>Добро пожаловать в панель управления!</p>
-
-    <!-- Добавьте проверку на администратора -->
-    <div v-if="isAdmin">
-      <h2>Административные функции</h2>
-      <AccessTokenManager />
-      <RoleManager />
-      <AccessControl />
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { computed } from 'vue';
-import { useAuthStore } from '../stores/auth';
-import AccessTokenManager from '../components/AccessTokenManager.vue';
-import RoleManager from '../components/RoleManager.vue';
-import AccessControl from '../components/AccessControl.vue';
-
-const authStore = useAuthStore();
-const isAdmin = computed(() => authStore.isAdmin);
-
-console.log('Статус администратора:', isAdmin.value); // Для отладки
-</script>

frontend/src/views/HomeView.vue

@@ -58,7 +58,6 @@ import { ref, computed, onMounted, watch, nextTick } from 'vue';
 import { useAuthStore } from '../stores/auth';
 import axios from 'axios';
 import WalletConnection from '../components/WalletConnection.vue';
-import { connectWallet } from '../utils/wallet';
 
 const auth = useAuthStore();
 const userInput = ref('');
@@ -72,9 +71,8 @@ const messages = ref([
 const chatMessages = ref(null);
 const isLoading = ref(false);
 const hasShownAuthMessage = ref(false);
-const userName = ref('');
-const userLanguage = ref('ru');
 const email = ref('');
+const userLanguage = ref('ru');
 
 // Проверка валидности email
 const isValidEmail = computed(() => {
@@ -130,6 +128,22 @@ async function sendMessage() {
   try {
     console.log('Отправка сообщения:', userMessage, 'язык:', userLanguage.value);
     
+    // Проверяем, авторизован ли пользователь
+    if (!auth.isAuthenticated && !hasShownAuthMessage.value) {
+      // Если пользователь не авторизован и мы еще не показывали сообщение с опциями авторизации
+      setTimeout(() => {
+        messages.value.push({
+          sender: 'ai',
+          text: 'Для продолжения общения и доступа ко всем функциям, пожалуйста, авторизуйтесь одним из способов:',
+          timestamp: new Date(),
+          showAuthOptions: true,
+        });
+        isLoading.value = false;
+        hasShownAuthMessage.value = true;
+      }, 1000);
+      return;
+    }
+    
     // Отправляем запрос к API
     const response = await axios.post(
       '/api/chat/message',
@@ -153,12 +167,23 @@ async function sendMessage() {
   } catch (error) {
     console.error('Error sending message:', error);
 
-    // Добавляем сообщение об ошибке
+    // Если ошибка связана с авторизацией (401)
-    messages.value.push({
+    if (error.response && error.response.status === 401 && !hasShownAuthMessage.value) {
-      sender: 'ai',
+      messages.value.push({
-      text: 'Извините, произошла ошибка при обработке вашего запроса. Пожалуйста, попробуйте позже.',
+        sender: 'ai',
-      timestamp: new Date(),
+        text: 'Для продолжения общения и доступа ко всем функциям, пожалуйста, авторизуйтесь одним из способов:',
-    });
+        timestamp: new Date(),
+        showAuthOptions: true,
+      });
+      hasShownAuthMessage.value = true;
+    } else {
+      // Добавляем сообщение об ошибке
+      messages.value.push({
+        sender: 'ai',
+        text: 'Извините, произошла ошибка при обработке вашего запроса. Пожалуйста, попробуйте позже.',
+        timestamp: new Date(),
+      });
+    }
   } finally {
     isLoading.value = false;
   }
@@ -176,9 +201,10 @@ function formatTime(timestamp) {
 async function connectTelegram() {
   try {
     // Отправляем запрос на получение ссылки для авторизации через Telegram
-    const response = await axios.get('/api/auth/telegram');
+    const response = await axios.get('/api/auth/telegram', {
+      withCredentials: true
+    });
     
-    // Если сервер вернул ошибку, показываем сообщение
     if (response.data.error) {
       messages.value.push({
         sender: 'ai',
@@ -188,7 +214,6 @@ async function connectTelegram() {
       return;
     }
     
-    // Если сервер вернул ссылку для авторизации, показываем её пользователю
     if (response.data.authUrl) {
       messages.value.push({
         sender: 'ai',
@@ -199,20 +224,15 @@ async function connectTelegram() {
       // Открываем ссылку в новом окне
       window.open(response.data.authUrl, '_blank');
     } else {
-      // Временное решение для обхода ошибок сервера
       messages.value.push({
         sender: 'ai',
         text: 'Для подключения Telegram, перейдите по <a href="https://t.me/YourBotName" target="_blank">этой ссылке</a> и авторизуйтесь.',
         timestamp: new Date(),
       });
-
-      // Открываем ссылку на бота в новом окне
-      window.open('https://t.me/YourBotName', '_blank');
     }
   } catch (error) {
     console.error('Error connecting with Telegram:', error);
     
-    // Показываем сообщение об ошибке
     messages.value.push({
       sender: 'ai',
       text: 'Извините, произошла ошибка при подключении Telegram. Пожалуйста, попробуйте позже.',
@@ -226,129 +246,89 @@ async function connectEmail() {
   if (!isValidEmail.value) return;
   
   try {
-    // Отправляем запрос на авторизацию по email
+    messages.value.push({
-    const response = await axios.post('/api/auth/email', { email: email.value });
+      sender: 'ai',
+      text: `Отправляем код подтверждения на ${email.value}...`,
+      timestamp: new Date(),
+    });
+    
+    // Отправляем запрос на отправку кода подтверждения
+    const response = await axios.post('/api/auth/email', {
+      email: email.value
+    }, {
+      withCredentials: true
+    });
     
-    // Если сервер вернул ошибку, показываем сообщение
     if (response.data.error) {
       messages.value.push({
         sender: 'ai',
-        text: `Ошибка при подключении Email: ${response.data.error}`,
+        text: `Ошибка: ${response.data.error}`,
         timestamp: new Date(),
       });
       return;
     }
     
-    // Если сервер вернул код подтверждения или сообщение об отправке письма
+    messages.value.push({
-    if (response.data.success) {
+      sender: 'ai',
-      messages.value.push({
+      text: `На ваш email ${email.value} отправлено письмо с кодом подтверждения. Пожалуйста, введите код:`,
-        sender: 'ai',
+      timestamp: new Date(),
-        text: `На ваш email ${email.value} отправлено письмо с кодом подтверждения. Пожалуйста, проверьте вашу почту и введите код:`,
+    });
-        timestamp: new Date(),
-      });
     
-      // Добавляем поле для ввода кода подтверждения
+    // Добавляем поле для ввода кода
-      messages.value.push({
+    const verificationCode = prompt('Введите код подтверждения:');
-        sender: 'ai',
-        text: '<div class="verification-code"><input type="text" placeholder="Введите код подтверждения" id="verification-code" /><button onclick="verifyEmailCode()">Подтвердить</button></div>',
-        timestamp: new Date(),
-      });
     
-      // Добавляем функцию для проверки кода в глобальный объект window
+    if (verificationCode) {
-      window.verifyEmailCode = async function () {
+      try {
-        const code = document.getElementById('verification-code').value;
+        // Отправляем запрос на проверку кода
-        if (!code) return;
+        const verifyResponse = await axios.post('/api/auth/email/verify', {
-
+          email: email.value,
-        try {
+          code: verificationCode
-          const verifyResponse = await axios.post('/api/auth/email/verify', {
+        }, {
-            email: email.value,
+          withCredentials: true
-            code,
+        });
-          });
-
-          if (verifyResponse.data.authenticated) {
-            auth.authenticated = true;
-            auth.address = email.value;
-            auth.isAdmin = verifyResponse.data.isAdmin;
-            auth.authType = 'email';
-
-            // Перезагружаем страницу для обновления интерфейса
-            window.location.reload();
-          } else {
-            messages.value.push({
-              sender: 'ai',
-              text: 'Неверный код подтверждения. Пожалуйста, попробуйте еще раз.',
-              timestamp: new Date(),
-            });
-          }
-        } catch (error) {
-          console.error('Error verifying email code:', error);
         
+        if (verifyResponse.data.error) {
           messages.value.push({
             sender: 'ai',
-            text: 'Произошла ошибка при проверке кода. Пожалуйста, попробуйте позже.',
+            text: `Ошибка: ${verifyResponse.data.error}`,
             timestamp: new Date(),
           });
+          return;
         }
-      };
-    } else {
-      // Временное решение для обхода ошибок сервера
-      messages.value.push({
-        sender: 'ai',
-        text: `На ваш email ${email.value} отправлено письмо с кодом подтверждения. Пожалуйста, проверьте вашу почту.`,
-        timestamp: new Date(),
-      });
         
-      // Имитируем успешную авторизацию через email
+        messages.value.push({
-      setTimeout(() => {
+          sender: 'ai',
-        auth.authenticated = true;
+          text: 'Email успешно подтвержден! Теперь вы можете использовать все функции чата.',
-        auth.address = email.value;
+          timestamp: new Date(),
-        auth.isAdmin = email.value.includes('admin');
+        });
+        
+        // Обновляем состояние аутентификации
+        auth.isAuthenticated = true;
+        auth.user = { email: email.value };
         auth.authType = 'email';
         
-        // Перезагружаем страницу для обновления интерфейса
+        // Сбрасываем флаг показа сообщения с опциями авторизации
-        window.location.reload();
+        hasShownAuthMessage.value = false;
-      }, 3000);
+      } catch (error) {
+        console.error('Error verifying email code:', error);
+        
+        messages.value.push({
+          sender: 'ai',
+          text: 'Произошла ошибка при проверке кода. Пожалуйста, попробуйте позже.',
+          timestamp: new Date(),
+        });
+      }
     }
   } catch (error) {
     console.error('Error connecting with email:', error);
     
-    // Показываем сообщение об ошибке
     messages.value.push({
       sender: 'ai',
       text: 'Извините, произошла ошибка при подключении Email. Пожалуйста, попробуйте позже.',
       timestamp: new Date(),
     });
-
-    // Временное решение для обхода ошибок сервера
-    messages.value.push({
-      sender: 'ai',
-      text: `На ваш email ${email.value} отправлено письмо с кодом подтверждения. Пожалуйста, проверьте вашу почту.`,
-      timestamp: new Date(),
-    });
-
-    // Имитируем успешную авторизацию через email
-    setTimeout(() => {
-      auth.authenticated = true;
-      auth.address = email.value;
-      auth.isAdmin = email.value.includes('admin');
-      auth.authType = 'email';
-
-      // Перезагружаем страницу для обновления интерфейса
-      window.location.reload();
-    }, 3000);
   }
 }
-
-// В функции обработчика клика
-function handleConnectWallet() {
-  connectWallet((errorMessage) => {
-    messages.value.push({
-      sender: 'ai',
-      text: errorMessage,
-      timestamp: new Date(),
-    });
-  });
-}
 </script>
 
 <style scoped>
@@ -387,6 +367,7 @@ h2 {
   display: flex;
   flex-direction: column;
   gap: 1rem;
+  min-height: 400px;
 }
 
 .message {
@@ -485,22 +466,6 @@ textarea {
   cursor: not-allowed;
 }
 
-.email-auth {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-  width: 100%;
-}
-
-.email-auth input {
-  padding: 0.75rem 1rem;
-  border: 1px solid #ddd;
-  border-radius: 4px;
-  font-size: 1rem;
-  width: 100%;
-  box-sizing: border-box;
-}
-
 /* Общие стили для всех кнопок аутентификации */
 .auth-btn {
   display: flex;
@@ -546,31 +511,4 @@ textarea {
   background-color: #4caf50;
   color: white;
 }
-
-/* Стили для поля ввода кода подтверждения */
-.verification-code {
-  display: flex;
-  gap: 0.5rem;
-  margin-top: 0.5rem;
-}
-
-.verification-code input {
-  flex: 1;
-  padding: 0.75rem 1rem;
-  border: 1px solid #ddd;
-  border-radius: 4px;
-  font-size: 1rem;
-  box-sizing: border-box;
-}
-
-.verification-code button {
-  padding: 0.75rem 1rem;
-  background-color: #4caf50;
-  color: white;
-  border: none;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 1rem;
-  font-weight: 500;
-}
 </style>

frontend/src/views/ProfileView.vue

@@ -56,7 +56,9 @@ export default {
     const loadProfile = async () => {
       try {
         loading.value = true;
-        const response = await axios.get('/api/users/profile');
+        const response = await axios.get('/api/users/profile', {
+          withCredentials: true
+        });
         profile.value = response.data;
         selectedLanguage.value = response.data.preferred_language || 'ru';
         isAdmin.value = response.data.role === 'admin';
@@ -73,6 +75,8 @@ export default {
       try {
         await axios.post('/api/users/update-language', {
           language: selectedLanguage.value
+        }, {
+          withCredentials: true
         });
         // Обновляем язык в профиле
         profile.value.preferred_language = selectedLanguage.value;

frontend/vite.config.js

@@ -16,7 +16,7 @@ export default defineConfig({
   ],
   resolve: {
     alias: {
-      '@': path.resolve(__dirname, './src'),
+      '@': path.resolve(__dirname, 'src'),
       buffer: 'buffer/',
     },
   },
@@ -42,7 +42,7 @@ export default defineConfig({
       '/api': {
         target: 'http://localhost:8000',
         changeOrigin: true,
-        cookieDomainRewrite: 'localhost',
+        secure: false
       }
     },
   },