Старт

.gitignore

@@ -0,0 +1,43 @@
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+.kotlin
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/artifacts/server_jar.xml

@@ -0,0 +1,10 @@
+<component name="ArtifactManager">
+  <artifact type="jar" build-on-make="true" name="server:jar">
+    <output-path>$PROJECT_DIR$/out/artifacts/server_jar</output-path>
+    <root id="archive" name="server.jar">
+      <element id="directory" name="META-INF">
+        <element id="file-copy" path="$PROJECT_DIR$/META-INF/MANIFEST.MF" />
+      </element>
+    </root>
+  </artifact>
+</component>

.idea/gradle.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleHome" value="" />
+        <option name="modules">
+          <set>
+            <option value="$PROJECT_DIR$" />
+            <option value="$PROJECT_DIR$/shine-server-blockchain" />
+            <option value="$PROJECT_DIR$/shine-server-config" />
+            <option value="$PROJECT_DIR$/shine-server-crypto" />
+            <option value="$PROJECT_DIR$/shine-server-db" />
+            <option value="$PROJECT_DIR$/shine-server-net-protocol" />
+            <option value="$PROJECT_DIR$/shine-server-net-server" />
+          </set>
+        </option>
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="FrameworkDetectionExcludesConfiguration">
+    <file type="web" url="file://$PROJECT_DIR$" />
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17 (2)" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: server.ws.WsServer
+

build.gradle

@@ -0,0 +1,72 @@
+plugins {
+    id 'java'
+    id 'application'
+    id 'com.github.johnrengelman.shadow' version '8.1.1'
+}
+
+group = 'shine'
+version = '1.0'
+
+tasks.jar {
+    enabled = false     // это что бы не создавала обычный джар, а будет только толстый джар
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'org.eclipse.jetty:jetty-server:11.0.20'
+    implementation 'org.eclipse.jetty:jetty-servlet:11.0.20'
+    implementation 'org.eclipse.jetty.websocket:websocket-jetty-server:11.0.20'
+    implementation 'org.bouncycastle:bcprov-jdk18on:1.78.1'              // шифрование
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'  // json
+
+    implementation 'org.slf4j:slf4j-api:2.0.9'
+    implementation 'ch.qos.logback:logback-classic:1.5.6'
+
+    testImplementation platform('org.junit:junit-bom:5.10.0')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+
+
+    implementation project(':shine-server-config')       // модуль настроек из application.properties
+    implementation project(':shine-server-crypto')       // модуль сервера для работы с криптографией
+    implementation project(':shine-server-blockchain')   // модуль для работы с блокчейном
+    implementation project(':shine-server-db')           // модуль для работы с БД содержит и сущности из БД и саму работу с БД
+
+    implementation project(':shine-server-net-protocol') // Модуль отвечающий за протокол (классы Net..Request/Response
+    implementation project(':shine-server-net-server')   // Хэндлеры для обработки сетевых запросов
+
+
+}
+
+application {
+    // 👇 класс с методом main
+    mainClass = 'server.ws.WsServer'
+}
+
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+
+shadowJar {
+    // создаём 1 файл без постфиксов
+    archiveBaseName.set('shine-server')
+    archiveClassifier.set('')
+    archiveVersion.set('')
+    mergeServiceFiles()
+
+    manifest {
+        attributes(
+                'Main-Class': 'server.ws.WsServer'
+        )
+    }
+}
+
+test {
+    useJUnitPlatform()
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Mon Oct 20 16:15:09 MSK 2025
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1,8 @@
+rootProject.name = 'shine-server-server'
+
+include 'shine-server-config'
+include 'shine-server-crypto'
+include 'shine-server-blockchain'
+include 'shine-server-db'
+include 'shine-server-net-protocol'
+include 'shine-server-net-server'

shine-server-blockchain/build.gradle

@@ -0,0 +1,33 @@
+plugins {
+    id 'java'
+}
+
+group = 'shine'
+version = '1.0.0'
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    // модуль блокчейна использует крипту
+    implementation project(':shine-server-crypto')
+
+    // JSON (BchInfoManager)
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.18.1'
+
+    // логгер
+    implementation 'org.slf4j:slf4j-api:2.0.16'
+
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'
+}
+
+test {
+    useJUnitPlatform()
+}

shine-server-config/build.gradle

@@ -0,0 +1,25 @@
+plugins {
+    id 'java'
+}
+
+group = 'shine'
+version = '1.0.0'
+
+repositories {
+    mavenCentral()
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+dependencies {
+    // обычно тут пусто, максимум логгер и тесты
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'
+}
+
+test {
+    useJUnitPlatform()
+}

shine-server-config/src/main/java/utils/config/AppConfig.java

@@ -0,0 +1,58 @@
+package utils.config;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+public final class AppConfig {
+
+    private static volatile AppConfig instance;
+    private final Properties properties = new Properties();
+
+    private AppConfig() {
+        load();
+    }
+
+    public static AppConfig getInstance() {
+        if (instance == null) {
+            synchronized (AppConfig.class) {
+                if (instance == null) {
+                    instance = new AppConfig();
+                }
+            }
+        }
+        return instance;
+    }
+
+    private void load() {
+        try (InputStream in = getClass().getClassLoader()
+                .getResourceAsStream("application.properties")) {
+
+            if (in == null) {
+                throw new RuntimeException("Config file application.properties not found");
+            }
+
+            properties.load(in);
+
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to load application.properties", e);
+        }
+    }
+
+    /** Вернёт значение строки или null, если параметр не найден */
+    public String getParam(String name) {
+        return properties.getProperty(name);
+    }
+
+    /** Можно добавить методы для удобства */
+    public int getInt(String name, int defaultValue) {
+        String v = properties.getProperty(name);
+        return v == null ? defaultValue : Integer.parseInt(v);
+    }
+
+    public boolean getBoolean(String name, boolean defaultValue) {
+        String v = properties.getProperty(name);
+        return v == null ? defaultValue : Boolean.parseBoolean(v);
+    }
+}

shine-server-db/build.gradle

@@ -0,0 +1,26 @@
+plugins {
+    id 'java'
+}
+
+group = 'shine'
+version = '1.0.0'
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'org.xerial:sqlite-jdbc:3.47.0.0'
+    implementation project(':shine-server-config')  // модуль с настройками
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

shine-server-db/concat_to_file.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+OUTFILE="all_files.txt"
+
+# очищаем или создаём файл
+: > "$OUTFILE"
+
+# собрать только *.java файлы и вывести их содержимое в файл
+find . -type f -name "*.java" | sort | while read -r f; do
+  cat "$f" >> "$OUTFILE"
+  echo >> "$OUTFILE"    # пустая строка-разделитель
+done
+
+echo "Готово! Все .java файлы собраны в $OUTFILE"
+

shine-server-db/src/main/java/shine/db/DatabaseInitializer.java

@@ -0,0 +1,126 @@
+package shine.db;
+
+
+import utils.config.AppConfig;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.*;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class DatabaseInitializer {
+
+    public static void createNewDB(String[] args) {
+        AppConfig config = AppConfig.getInstance();
+        String dbPath = config.getParam("db.path");
+
+        if (dbPath == null || dbPath.isBlank()) {
+            System.err.println("Параметр db.path не задан в application.properties");
+            return;
+        }
+
+        Path dbFile = Paths.get(dbPath);
+        try {
+            // создаём директорию, если нужно
+            Path parent = dbFile.getParent();
+            if (parent != null && !Files.exists(parent)) {
+                Files.createDirectories(parent);
+            }
+
+            if (Files.exists(dbFile)) {
+                System.out.println("Файл базы данных уже существует: " + dbFile.toAbsolutePath());
+                System.out.print("Пересоздать БД (СТАРАЯ БУДЕТ УДАЛЕНА)? [y/N]: ");
+
+                BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+                String answer = reader.readLine();
+                if (!"y".equalsIgnoreCase(answer) && !"yes".equalsIgnoreCase(answer)) {
+                    System.out.println("Операция отменена. БД не изменена.");
+                    return;
+                }
+
+                Files.delete(dbFile);
+                System.out.println("Старый файл БД удалён.");
+            }
+
+            createSchema("jdbc:sqlite:" + dbPath);
+            System.out.println("Новая БД успешно создана по пути: " + dbFile.toAbsolutePath());
+
+        } catch (IOException e) {
+            System.err.println("Ошибка работы с файлом БД: " + e.getMessage());
+        } catch (SQLException e) {
+            System.err.println("Ошибка создания схемы БД: " + e.getMessage());
+        }
+    }
+
+    private static void createSchema(String jdbcUrl) throws SQLException {
+        try {
+            Class.forName("org.sqlite.JDBC");
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("SQLite JDBC driver not found", e);
+        }
+
+        try (Connection conn = DriverManager.getConnection(jdbcUrl);
+             Statement st = conn.createStatement()) {
+
+            // включаем внешние ключи на этом соединении (для инициализации тоже)
+            st.execute("PRAGMA foreign_keys = ON");
+
+            // 1. Таблица solana_users
+            st.executeUpdate("""
+                CREATE TABLE IF NOT EXISTS solana_users (
+                    login       TEXT    NOT NULL,
+                    loginId     INTEGER NOT NULL PRIMARY KEY,
+                    bchId       INTEGER NOT NULL,
+                    pubkey0     TEXT,
+                    pubkey1     TEXT,
+                    bchLimit    INTEGER         -- может быть NULL
+                );
+                """);
+
+            st.executeUpdate("""
+                CREATE INDEX IF NOT EXISTS idx_solana_users_login
+                ON solana_users (login);
+                """);
+
+            // 2. Таблица active_sessions
+            st.executeUpdate("""
+                CREATE TABLE IF NOT EXISTS active_sessions (
+                    sessionId        INTEGER NOT NULL PRIMARY KEY,
+                    session_pwd      TEXT    NOT NULL,
+                    loginId          INTEGER NOT NULL,
+                    time_ms          INTEGER NOT NULL,
+                    pubkey_num       INTEGER NOT NULL,
+                    push_endpoint    TEXT,
+                    push_p256dh_key  TEXT,
+                    push_auth_key    TEXT,
+                    FOREIGN KEY (loginId) REFERENCES solana_users(loginId)
+                );
+                """);
+
+            // 3. Таблица users_params
+            // Важно: пара (loginId, param) должна быть уникальна
+            st.executeUpdate("""
+                CREATE TABLE IF NOT EXISTS users_params (
+                    loginId        INTEGER NOT NULL,
+                    param          TEXT    NOT NULL,
+                    bch_channel_id INTEGER NOT NULL DEFAULT 0,
+                    value          TEXT,
+                    time_ms        INTEGER NOT NULL,
+                    pubkey_num     INTEGER NOT NULL,
+                    signature      TEXT,
+                    FOREIGN KEY (loginId) REFERENCES solana_users(loginId),
+                    UNIQUE (loginId, param)
+                );
+                """);
+
+            st.executeUpdate("""
+                CREATE INDEX IF NOT EXISTS idx_users_params_loginId
+                ON users_params (loginId);
+                """);
+        }
+    }
+}

shine-server-db/src/main/java/shine/db/SqliteDbController.java

@@ -0,0 +1,82 @@
+package shine.db;
+
+import shine.db.dao.ActiveSessionsDAO;
+import utils.config.AppConfig;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public final class SqliteDbController {
+
+    private static volatile SqliteDbController instance;
+    private final Connection connection;
+
+    private SqliteDbController() {
+        try {
+            // Подгружаем драйвер SQLite
+            Class.forName("org.sqlite.JDBC");
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("SQLite JDBC driver not found", e);
+        }
+
+        String dbPath = AppConfig.getInstance().getParam("db.path");
+
+        if (dbPath == null || dbPath.isBlank()) {
+            throw new RuntimeException("Config param 'db.path' is not set in application.properties");
+        }
+
+        Path dbFile = Paths.get(dbPath);
+
+        // 👉 Если файла БД нет — создаём новую БД через DatabaseInitializer
+        if (!Files.exists(dbFile)) {
+            System.out.println("[DB] Файл БД не найден: " + dbFile.toAbsolutePath());
+            System.out.println("[DB] Создаём новую БД с помощью DatabaseInitializer...");
+
+            // можно передать пустой массив аргументов
+            DatabaseInitializer.createNewDB(new String[0]);
+        }
+
+        String url = "jdbc:sqlite:" + dbPath;
+
+        try {
+            this.connection = DriverManager.getConnection(url);
+            this.connection.setAutoCommit(true);
+
+            // ВАЖНО: включаем поддержку внешних ключей для этого соединения
+            try (Statement st = this.connection.createStatement()) {
+                st.execute("PRAGMA foreign_keys = ON");
+            }
+
+        } catch (SQLException e) {
+            throw new RuntimeException("Failed to connect to SQLite database: " + url, e);
+        }
+    }
+
+    public static SqliteDbController getInstance() {
+        if (instance == null) {
+            synchronized (SqliteDbController.class) {
+                if (instance == null) {
+                    instance = new SqliteDbController();
+                }
+            }
+        }
+        return instance;
+    }
+
+    public Connection getConnection() {
+        return connection;
+    }
+
+    public void close() {
+        try {
+            connection.close();
+        } catch (SQLException e) {
+            // логировать по необходимости
+        }
+    }
+}

shine-server-db/src/main/java/shine/db/dao/ActiveSessionsDAO.java

@@ -0,0 +1,116 @@
+package shine.db.dao;
+
+import shine.db.SqliteDbController;
+import shine.db.entities.ActiveSession;
+
+import java.sql.*;
+
+/** Здесь мы хрним данные об активных сессиях пользователя (для wss соединений) */
+
+public final class ActiveSessionsDAO {
+
+    private static volatile ActiveSessionsDAO instance;
+    private final SqliteDbController db = SqliteDbController.getInstance();
+
+    private ActiveSessionsDAO() {
+    }
+
+    public static ActiveSessionsDAO getInstance() {
+        if (instance == null) {
+            synchronized (ActiveSessionsDAO.class) {
+                if (instance == null) {
+                    instance = new ActiveSessionsDAO();
+                }
+            }
+        }
+        return instance;
+    }
+
+    public void insert(ActiveSession session) throws SQLException {
+        String sql = """
+            INSERT INTO active_sessions (
+                sessionId,
+                session_pwd,
+                loginId,
+                time_ms,
+                pubkey_num,
+                push_endpoint,
+                push_p256dh_key,
+                push_auth_key
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """;
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setLong(1, session.getSessionId());
+            ps.setString(2, session.getSessionPwd());
+            ps.setLong(3, session.getLoginId());
+            ps.setLong(4, session.getTimeMs());
+            ps.setInt(5, session.getPubkeyNum());
+            ps.setString(6, session.getPushEndpoint());
+            ps.setString(7, session.getPushP256dhKey());
+            ps.setString(8, session.getPushAuthKey());
+            ps.executeUpdate();
+        }
+    }
+
+    public ActiveSession getBySessionId(long sessionId) throws SQLException {
+        String sql = """
+            SELECT
+                sessionId,
+                session_pwd,
+                loginId,
+                time_ms,
+                pubkey_num,
+                push_endpoint,
+                push_p256dh_key,
+                push_auth_key
+            FROM active_sessions
+            WHERE sessionId = ?
+            """;
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setLong(1, sessionId);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (!rs.next()) {
+                    return null;
+                }
+                return mapRow(rs);
+            }
+        }
+    }
+
+    /**
+     * Удаление записи по sessionId.
+     * Если записи нет — просто ничего не удалит (0 строк).
+     */
+    public void deleteBySessionId(long sessionId) throws SQLException {
+        String sql = "DELETE FROM active_sessions WHERE sessionId = ?";
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setLong(1, sessionId);
+            ps.executeUpdate();
+        }
+    }
+
+    private ActiveSession mapRow(ResultSet rs) throws SQLException {
+        long sessionId = rs.getLong("sessionId");
+        String sessionPwd = rs.getString("session_pwd");
+        long loginId = rs.getLong("loginId");
+        long timeMs = rs.getLong("time_ms");
+        short pubkeyNum = (short) rs.getInt("pubkey_num");
+        String pushEndpoint = rs.getString("push_endpoint");
+        String pushP256dhKey = rs.getString("push_p256dh_key");
+        String pushAuthKey = rs.getString("push_auth_key");
+
+        return new ActiveSession(
+                sessionId,
+                sessionPwd,
+                loginId,
+                timeMs,
+                pubkeyNum,
+                pushEndpoint,
+                pushP256dhKey,
+                pushAuthKey
+        );
+    }
+}

shine-server-db/src/main/java/shine/db/dao/SolanaUsersDAO.java

@@ -0,0 +1,119 @@
+package shine.db.dao;
+
+import shine.db.SqliteDbController;
+import shine.db.entities.SolanaUser;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Здесь храним данные об пользователях - локальная копия того что есть в солане */
+
+public final class SolanaUsersDAO {
+
+    private static volatile SolanaUsersDAO instance;
+    private final SqliteDbController db = SqliteDbController.getInstance();
+
+    private SolanaUsersDAO() {}
+
+    public static SolanaUsersDAO getInstance() {
+        if (instance == null) {
+            synchronized (SolanaUsersDAO.class) {
+                if (instance == null) {
+                    instance = new SolanaUsersDAO();
+                }
+            }
+        }
+        return instance;
+    }
+
+    public void insert(SolanaUser user) throws SQLException {
+        String sql = """
+            INSERT INTO solana_users (login, loginId, bchId, pubkey0, pubkey1, bchLimit)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """;
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setString(1, user.getLogin());
+            ps.setLong(2, user.getLoginId());
+            ps.setLong(3, user.getBchId());
+            ps.setString(4, user.getPubkey0());
+            ps.setString(5, user.getPubkey1());
+
+            if (user.getBchLimit() != null) {
+                ps.setInt(6, user.getBchLimit());
+            } else {
+                ps.setNull(6, Types.INTEGER);
+            }
+
+            ps.executeUpdate();
+        }
+    }
+
+    public SolanaUser getByLoginId(long loginId) throws SQLException {
+        String sql = """
+            SELECT login, loginId, bchId, pubkey0, pubkey1, bchLimit
+            FROM solana_users
+            WHERE loginId = ?
+            """;
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setLong(1, loginId);
+
+            try (ResultSet rs = ps.executeQuery()) {
+                if (!rs.next()) return null;
+                return mapRow(rs);
+            }
+        }
+    }
+
+    public SolanaUser getByLogin(String login) throws SQLException {
+        String sql = """
+            SELECT login, loginId, bchId, pubkey0, pubkey1, bchLimit
+            FROM solana_users
+            WHERE LOWER(login) = LOWER(?)
+            """;
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setString(1, login);
+
+            try (ResultSet rs = ps.executeQuery()) {
+                if (!rs.next()) return null;
+                return mapRow(rs);
+            }
+        }
+    }
+
+    public List<SolanaUser> searchByLoginPrefix(String prefix) throws SQLException {
+        String sql = """
+            SELECT login, loginId, bchId, pubkey0, pubkey1, bchLimit
+            FROM solana_users
+            WHERE LOWER(login) LIKE ?
+            ORDER BY login
+            LIMIT 5
+            """;
+
+        List<SolanaUser> result = new ArrayList<>();
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setString(1, prefix.toLowerCase() + "%");
+
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) result.add(mapRow(rs));
+            }
+        }
+
+        return result;
+    }
+
+    private SolanaUser mapRow(ResultSet rs) throws SQLException {
+        return new SolanaUser(
+                rs.getLong("loginId"),
+                rs.getString("login"),
+                rs.getLong("bchId"),
+                rs.getString("pubkey0"),
+                rs.getString("pubkey1"),
+                rs.getObject("bchLimit") != null ? rs.getInt("bchLimit") : null
+        );
+    }
+}

shine-server-db/src/main/java/shine/db/dao/UserParamsDAO.java

@@ -0,0 +1,136 @@
+package shine.db.dao;
+
+import shine.db.SqliteDbController;
+import shine.db.entities.UserParam;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Здесь зраним сохранённые параметры пользователей (в основном до каково сообщения просмотрены ленты) */
+
+public final class UserParamsDAO {
+
+    private static volatile UserParamsDAO instance;
+    private final SqliteDbController db = SqliteDbController.getInstance();
+
+    private UserParamsDAO() {
+    }
+
+    public static UserParamsDAO getInstance() {
+        if (instance == null) {
+            synchronized (UserParamsDAO.class) {
+                if (instance == null) {
+                    instance = new UserParamsDAO();
+                }
+            }
+        }
+        return instance;
+    }
+
+    /**
+     * UPSERT методом ON CONFLICT — одним SQL-запросом.
+     * Если запись существует -> обновляем поля.
+     * Если нет -> вставляем новую запись.
+     */
+    public void upsert(UserParam param) throws SQLException {
+        String sql = """
+            INSERT INTO users_params (
+                loginId,
+                param,
+                bch_channel_id,
+                value,
+                time_ms,
+                pubkey_num,
+                signature
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(loginId, param)
+            DO UPDATE SET
+                bch_channel_id = excluded.bch_channel_id,
+                value          = excluded.value,
+                time_ms        = excluded.time_ms,
+                pubkey_num     = excluded.pubkey_num,
+                signature      = excluded.signature
+            """;
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setLong(1, param.getLoginId());
+            ps.setString(2, param.getParam());
+            ps.setLong(3, param.getBchChannelId());
+            ps.setString(4, param.getValue());
+            ps.setLong(5, param.getTimeMs());
+            ps.setInt(6, param.getPubkeyNum());
+            ps.setString(7, param.getSignature());
+            ps.executeUpdate();
+        }
+    }
+
+    /**
+     * Получить параметр по loginId + param.
+     */
+    public UserParam getByUserIdAndParam(long loginId, String paramName) throws SQLException {
+        String sql = """
+            SELECT
+                loginId,
+                param,
+                bch_channel_id,
+                value,
+                time_ms,
+                pubkey_num,
+                signature
+            FROM users_params
+            WHERE loginId = ? AND param = ?
+            """;
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setLong(1, loginId);
+            ps.setString(2, paramName);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (!rs.next()) return null;
+                return mapRow(rs);
+            }
+        }
+    }
+
+    /**
+     * Получить все параметры пользователя.
+     */
+    public List<UserParam> getByUserId(long loginId) throws SQLException {
+        String sql = """
+            SELECT
+                loginId,
+                param,
+                bch_channel_id,
+                value,
+                time_ms,
+                pubkey_num,
+                signature
+            FROM users_params
+            WHERE loginId = ?
+            ORDER BY time_ms DESC
+            """;
+
+        List<UserParam> result = new ArrayList<>();
+
+        try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
+            ps.setLong(1, loginId);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) result.add(mapRow(rs));
+            }
+        }
+
+        return result;
+    }
+
+    private UserParam mapRow(ResultSet rs) throws SQLException {
+        return new UserParam(
+                rs.getLong("loginId"),
+                rs.getString("param"),
+                rs.getLong("bch_channel_id"),
+                rs.getString("value"),
+                rs.getLong("time_ms"),
+                (short) rs.getInt("pubkey_num"),
+                rs.getString("signature")
+        );
+    }
+}

shine-server-db/src/main/java/shine/db/entities/ActiveSession.java

@@ -0,0 +1,98 @@
+package shine.db.entities;
+
+public class ActiveSession {
+
+    private long sessionId;
+    private String sessionPwd;
+    private long loginId;
+    private long timeMs;       // время в мс
+    private short pubkeyNum;
+    private String pushEndpoint;
+    private String pushP256dhKey;
+    private String pushAuthKey;
+
+    public ActiveSession() {
+    }
+
+    public ActiveSession(long sessionId,
+                         String sessionPwd,
+                         long loginId,
+                         long timeMs,
+                         short pubkeyNum,
+                         String pushEndpoint,
+                         String pushP256dhKey,
+                         String pushAuthKey) {
+        this.sessionId = sessionId;
+        this.sessionPwd = sessionPwd;
+        this.loginId = loginId;
+        this.timeMs = timeMs;
+        this.pubkeyNum = pubkeyNum;
+        this.pushEndpoint = pushEndpoint;
+        this.pushP256dhKey = pushP256dhKey;
+        this.pushAuthKey = pushAuthKey;
+    }
+
+    public long getSessionId() {
+        return sessionId;
+    }
+
+    public void setSessionId(long sessionId) {
+        this.sessionId = sessionId;
+    }
+
+    public String getSessionPwd() {
+        return sessionPwd;
+    }
+
+    public void setSessionPwd(String sessionPwd) {
+        this.sessionPwd = sessionPwd;
+    }
+
+    public long getLoginId() {
+        return loginId;
+    }
+
+    public void setLoginId(long loginId) {
+        this.loginId = loginId;
+    }
+
+    public long getTimeMs() {
+        return timeMs;
+    }
+
+    public void setTimeMs(long timeMs) {
+        this.timeMs = timeMs;
+    }
+
+    public short getPubkeyNum() {
+        return pubkeyNum;
+    }
+
+    public void setPubkeyNum(short pubkeyNum) {
+        this.pubkeyNum = pubkeyNum;
+    }
+
+    public String getPushEndpoint() {
+        return pushEndpoint;
+    }
+
+    public void setPushEndpoint(String pushEndpoint) {
+        this.pushEndpoint = pushEndpoint;
+    }
+
+    public String getPushP256dhKey() {
+        return pushP256dhKey;
+    }
+
+    public void setPushP256dhKey(String pushP256dhKey) {
+        this.pushP256dhKey = pushP256dhKey;
+    }
+
+    public String getPushAuthKey() {
+        return pushAuthKey;
+    }
+
+    public void setPushAuthKey(String pushAuthKey) {
+        this.pushAuthKey = pushAuthKey;
+    }
+}

shine-server-db/src/main/java/shine/db/entities/SolanaUser.java

@@ -0,0 +1,76 @@
+package shine.db.entities;
+
+public class SolanaUser {
+
+    private long loginId;
+    private String login;
+    private long bchId;
+    private String pubkey0;
+    private String pubkey1;
+    private Integer bchLimit;   // может быть null
+
+    public SolanaUser() {
+    }
+
+    public SolanaUser(long loginId,
+                      String login,
+                      long bchId,
+                      String pubkey0,
+                      String pubkey1,
+                      Integer bchLimit) {
+        this.loginId = loginId;
+        this.login = login;
+        this.bchId = bchId;
+        this.pubkey0 = pubkey0;
+        this.pubkey1 = pubkey1;
+        this.bchLimit = bchLimit;
+    }
+
+    public long getLoginId() {
+        return loginId;
+    }
+
+    public void setLoginId(long loginId) {
+        this.loginId = loginId;
+    }
+
+    public String getLogin() {
+        return login;
+    }
+
+    public void setLogin(String login) {
+        this.login = login;
+    }
+
+    public long getBchId() {
+        return bchId;
+    }
+
+    public void setBchId(long bchId) {
+        this.bchId = bchId;
+    }
+
+    public String getPubkey0() {
+        return pubkey0;
+    }
+
+    public void setPubkey0(String pubkey0) {
+        this.pubkey0 = pubkey0;
+    }
+
+    public String getPubkey1() {
+        return pubkey1;
+    }
+
+    public void setPubkey1(String pubkey1) {
+        this.pubkey1 = pubkey1;
+    }
+
+    public Integer getBchLimit() {
+        return bchLimit;
+    }
+
+    public void setBchLimit(Integer bchLimit) {
+        this.bchLimit = bchLimit;
+    }
+}

shine-server-db/src/main/java/shine/db/entities/UserParam.java

@@ -0,0 +1,87 @@
+package shine.db.entities;
+
+public class UserParam {
+
+    private long loginId;
+    private String param;
+    private long bchChannelId;   // новый канал, 8 байт, может быть 0
+    private String value;
+    private long timeMs;         // время в мс
+    private short pubkeyNum;
+    private String signature;
+
+    public UserParam() {
+    }
+
+    public UserParam(long loginId,
+                     String param,
+                     long bchChannelId,
+                     String value,
+                     long timeMs,
+                     short pubkeyNum,
+                     String signature) {
+        this.loginId = loginId;
+        this.param = param;
+        this.bchChannelId = bchChannelId;
+        this.value = value;
+        this.timeMs = timeMs;
+        this.pubkeyNum = pubkeyNum;
+        this.signature = signature;
+    }
+
+    public long getLoginId() {
+        return loginId;
+    }
+
+    public void setLoginId(long loginId) {
+        this.loginId = loginId;
+    }
+
+    public String getParam() {
+        return param;
+    }
+
+    public void setParam(String param) {
+        this.param = param;
+    }
+
+    public long getBchChannelId() {
+        return bchChannelId;
+    }
+
+    public void setBchChannelId(long bchChannelId) {
+        this.bchChannelId = bchChannelId;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    public long getTimeMs() {
+        return timeMs;
+    }
+
+    public void setTimeMs(long timeMs) {
+        this.timeMs = timeMs;
+    }
+
+    public short getPubkeyNum() {
+        return pubkeyNum;
+    }
+
+    public void setPubkeyNum(short pubkeyNum) {
+        this.pubkeyNum = pubkeyNum;
+    }
+
+    public String getSignature() {
+        return signature;
+    }
+
+    public void setSignature(String signature) {
+        this.signature = signature;
+    }
+}

shine-server-db/src/main/java/Описание таблиц в БД.md

@@ -0,0 +1,44 @@
+# Структура БД SHiNE (кратко)
+
+## Таблица `solana_users`
+Локальная копия данных о пользователях из Solana.
+
+Поля:
+- `login` (TEXT) — логин пользователя.
+- `loginId` (INTEGER, PK) — ID пользователя, основной ключ.
+- `bchId` (INTEGER) — ID блокчейна пользователя.
+- `pubkey0` (TEXT) — первый публичный ключ.
+- `pubkey1` (TEXT) — второй публичный ключ.
+- `bchLimit` (INTEGER, NULL) — произвольный лимит для пользователя (опционально).
+
+---
+
+## Таблица `active_sessions`
+Активные сессии пользователей (WebSocket/WSS + Web Push).
+
+Поля:
+- `sessionId` (INTEGER, PK) — ID сессии, генерируется приложением.
+- `session_pwd` (TEXT) — секрет/пароль сессии.
+- `loginId` (INTEGER, FK → solana_users.loginId) — владелец сессии.
+- `time_ms` (INTEGER) — время создания/активности сессии (мс от эпохи).
+- `pubkey_num` (INTEGER) — номер ключа пользователя, которым подписывались данные.
+- `push_endpoint` (TEXT, NULL) — endpoint Web Push.
+- `push_p256dh_key` (TEXT, NULL) — p256dh-ключ Web Push.
+- `push_auth_key` (TEXT, NULL) — auth-ключ Web Push.
+
+---
+
+## Таблица `users_params`
+Сохранённые параметры и состояния пользователя (например, до какого сообщения прочитана лента).
+
+Поля:
+- `loginId` (INTEGER, FK → solana_users.loginId) — пользователь.
+- `param` (TEXT) — имя параметра (ключ).
+- `bch_channel_id` (INTEGER, DEFAULT 0) — ID канала/ленты который просмотрен.
+- `value` (TEXT, NULL) — значение параметра (строка).
+- `time_ms` (INTEGER) — время последнего обновления (мс от эпохи).
+- `pubkey_num` (INTEGER) — номер ключа, которым подписано значение.
+- `signature` (TEXT, NULL) — подпись значения.
+
+Ограничения:
+- `UNIQUE(loginId, param)` — у одного пользователя каждый `param` только один раз.

shine-server-net-protocol/build.gradle

@@ -0,0 +1,35 @@
+plugins {
+    id 'java'
+}
+
+group = 'shine'
+version = '1.0.0'
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'  // json
+
+    implementation 'org.slf4j:slf4j-api:2.0.9'
+    implementation 'ch.qos.logback:logback-classic:1.5.6'
+
+    implementation project(':shine-server-config')       // модуль с настройками
+    implementation project(':shine-server-db')           // модуль для работы с БД содержит и сущности из БД и саму работу с БД
+
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+
+

shine-server-net-protocol/concat_to_file.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+OUTFILE="all_files.txt"
+
+# очищаем или создаём файл
+: > "$OUTFILE"
+
+# собрать только *.java файлы и вывести их содержимое в файл
+find . -type f -name "*.java" | sort | while read -r f; do
+  cat "$f" >> "$OUTFILE"
+  echo >> "$OUTFILE"    # пустая строка-разделитель
+done
+
+echo "Готово! Все .java файлы собраны в $OUTFILE"
+

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/ConnectionContext.java

@@ -0,0 +1,137 @@
+package server.logic.ws_protocol.JSON;
+
+/**
+ * ConnectionContext — контекст состояния одного WebSocket-соединения.
+ * Живёт ровно столько же, сколько живёт подключение.
+ */
+public class ConnectionContext {
+
+    // Статусы аутентификации
+    public static final int AUTH_STATUS_NONE = 0; // ананимный или не авторизованный пользователь
+    public static final int AUTH_STATUS_USER = 1; // авторизованный пользователь
+//    public static final int AUTH_STATUS_ANON = 2; // анонимный (зарезервировано на будущее)
+
+    private String login;
+    private Long loginId;
+
+    private Long sessionId;
+    private String sessionPwd;
+
+    // Данные пользователя / блокчейна
+    private Long bchId;
+    private String pubkey0;
+    private String pubkey1;
+    private Integer bchLimit;
+
+    private int authenticationStatus = AUTH_STATUS_NONE;
+
+    // --- getters / setters ---
+
+    public String getLogin() {
+        return login;
+    }
+
+    public void setLogin(String login) {
+        this.login = login;
+    }
+
+    public Long getLoginId() {
+        return loginId;
+    }
+
+    public void setLoginId(Long loginId) {
+        this.loginId = loginId;
+    }
+
+    public Long getSessionId() {
+        return sessionId;
+    }
+
+    public void setSessionId(Long sessionId) {
+        this.sessionId = sessionId;
+    }
+
+    public String getSessionPwd() {
+        return sessionPwd;
+    }
+
+    public void setSessionPwd(String sessionPwd) {
+        this.sessionPwd = sessionPwd;
+    }
+
+    public Long getBchId() {
+        return bchId;
+    }
+
+    public void setBchId(Long bchId) {
+        this.bchId = bchId;
+    }
+
+    public String getPubkey0() {
+        return pubkey0;
+    }
+
+    public void setPubkey0(String pubkey0) {
+        this.pubkey0 = pubkey0;
+    }
+
+    public String getPubkey1() {
+        return pubkey1;
+    }
+
+    public void setPubkey1(String pubkey1) {
+        this.pubkey1 = pubkey1;
+    }
+
+    public Integer getBchLimit() {
+        return bchLimit;
+    }
+
+    public void setBchLimit(Integer bchLimit) {
+        this.bchLimit = bchLimit;
+    }
+
+    public int getAuthenticationStatus() {
+        return authenticationStatus;
+    }
+
+    public void setAuthenticationStatus(int authenticationStatus) {
+        this.authenticationStatus = authenticationStatus;
+    }
+
+    public boolean isAuthenticatedUser() {
+        return authenticationStatus == AUTH_STATUS_USER;
+    }
+
+    public boolean isAnonymous() {
+        return authenticationStatus == AUTH_STATUS_NONE;
+    }
+
+    public void reset() {
+        login = null;
+        loginId = null;
+        sessionId = null;
+        sessionPwd = null;
+
+        bchId = null;
+        pubkey0 = null;
+        pubkey1 = null;
+        bchLimit = null;
+
+        authenticationStatus = AUTH_STATUS_NONE;
+    }
+
+    @Override
+    public String toString() {
+        return "ConnectionContext{" +
+                "login='" + login + '\'' +
+                ", loginId=" + loginId +
+                ", sessionId=" + sessionId +
+                ", bchId=" + bchId +
+                ", pubkey0='" + pubkey0 + '\'' +
+                ", pubkey1='" + pubkey1 + '\'' +
+                ", bchLimit=" + bchLimit +
+                ", authenticationStatus=" + authenticationStatus +
+                '}';
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java

@@ -0,0 +1,49 @@
+package server.logic.ws_protocol.JSON;
+
+import server.logic.ws_protocol.JSON.entyties.*;
+import server.logic.ws_protocol.JSON.entyties.Auth.NetAuthSessionNewStep1Request;
+import server.logic.ws_protocol.JSON.entyties.Auth.NetSessionRefreshRequest;
+import server.logic.ws_protocol.JSON.handlers.*;
+import server.logic.ws_protocol.JSON.entyties.tempToTest.NetAddUserRequest;
+import server.logic.ws_protocol.JSON.handlers.auth.NetAddUserHandler;
+import server.logic.ws_protocol.JSON.handlers.auth.NetAuthSessionNewStep1Handler;
+import server.logic.ws_protocol.JSON.handlers.auth.NetSessionRefreshHandler;
+
+import java.util.Map;
+
+/**
+ * JsonHandlerRegistry — единое место, где руками регистрируются
+ * JSON-операции: op → handler и op → requestClass.
+ *
+ * Если нужно добавить новый запрос:
+ *   1) создаёшь класс NetXXXRequest / NetXXXResponse,
+ *   2) создаёшь JsonMessageHandler (NetXXXHandler),
+ *   3) добавляешь оп в HANDLERS и REQUEST_TYPES.
+ */
+public final class JsonHandlerRegistry {
+
+    private static final Map<String, JsonMessageHandler> HANDLERS = Map.of(
+            "SessionRefresh", new NetSessionRefreshHandler(),
+            "AddUser",        new NetAddUserHandler(),
+            "AuthSessionNewStep1", new NetAuthSessionNewStep1Handler()
+            // сюда потом добавишь другие операции
+    );
+
+    private static final Map<String, Class<? extends NetRequest>> REQUEST_TYPES = Map.of(
+            "SessionRefresh", NetSessionRefreshRequest.class,
+            "AddUser",        NetAddUserRequest.class,
+            "AuthSessionNewStep1", NetAuthSessionNewStep1Request.class
+    );
+
+    private JsonHandlerRegistry() {
+        // utility
+    }
+
+    public static Map<String, JsonMessageHandler> getHandlers() {
+        return HANDLERS;
+    }
+
+    public static Map<String, Class<? extends NetRequest>> getRequestTypes() {
+        return REQUEST_TYPES;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonInboundProcessor.java

@@ -0,0 +1,158 @@
+package server.logic.ws_protocol.JSON;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.JSON.entyties.NetRequest;
+import server.logic.ws_protocol.JSON.entyties.NetResponse;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.WireCodes;
+
+import java.util.Map;
+
+/**
+ * JsonInboundProcessor — отдельный класс для обработки JSON-сообщений.
+ *
+ * 1) Парсит общий пакет (op, requestId, payload).
+ * 2) По op выбирает класс запроса и хэндлер.
+ * 3) Маппит JSON → NetRequest через ObjectMapper.
+ * 4) Вызывает хэндлер, получает NetResponse.
+ * 5) Собирает JSON-ответ и возвращает строкой.
+ */
+public final class JsonInboundProcessor {
+    private static final Logger log = LoggerFactory.getLogger(JsonInboundProcessor.class);
+
+    private static final ObjectMapper JSON_MAPPER = new ObjectMapper();
+
+    /**
+     * op → хэндлер.
+     * Регистрация вынесена в JsonHandlerRegistry.
+     */
+    private static final Map<String, JsonMessageHandler> JSON_HANDLERS =
+            JsonHandlerRegistry.getHandlers();
+
+    /**
+     * op → класс запроса.
+     */
+    private static final Map<String, Class<? extends NetRequest>> JSON_REQUEST_TYPES =
+            JsonHandlerRegistry.getRequestTypes();
+
+    private JsonInboundProcessor() {}
+
+    /**
+     * Обработка входящего JSON-сообщения.
+     *
+     * @param json исходная строка от клиента
+     * @param ctx  контекст текущего WebSocket-соединения
+     * @return JSON-строка ответа
+     */
+    public static String processJson(String json, ConnectionContext ctx) {
+        try {
+            if (json == null || json.isBlank()) {
+                return buildErrorJson(null, null, WireCodes.Status.BAD_REQUEST,
+                        "EMPTY_JSON", "Пустое JSON-сообщение");
+            }
+
+            // 1. Парсим общий пакет как дерево
+            JsonNode root = JSON_MAPPER.readTree(json);
+
+            // 2. Берём op и requestId
+            String op = getTextOrNull(root, "op");
+            if (op == null || op.isEmpty()) {
+                return buildErrorJson(null, null, WireCodes.Status.BAD_REQUEST,
+                        "NO_OP", "Поле 'op' отсутствует или пустое");
+            }
+
+            String requestId = getTextOrNull(root, "requestId");
+
+            JsonMessageHandler handler = JSON_HANDLERS.get(op);
+            Class<? extends NetRequest> reqClass = JSON_REQUEST_TYPES.get(op);
+
+            if (handler == null || reqClass == null) {
+                return buildErrorJson(op, requestId, WireCodes.Status.BAD_REQUEST,
+                        "UNKNOWN_OP", "Неизвестная операция: " + op);
+            }
+
+            // 3. Маппим весь JSON в конкретный класс запроса
+            NetRequest request = JSON_MAPPER.treeToValue(root, reqClass);
+
+            // 4. Вызываем хэндлер, передавая контекст
+            NetResponse response = handler.handle(request, ctx);
+
+            // На всякий случай: если хэндлер не выставил op/requestId
+            if (response.getOp() == null) {
+                response.setOp(op);
+            }
+            if (response.getRequestId() == null) {
+                response.setRequestId(requestId);
+            }
+
+            // 5. Собираем JSON-ответ
+            ObjectNode out = JSON_MAPPER.createObjectNode();
+            out.put("op", response.getOp());
+            out.put("requestId", response.getRequestId());
+            out.put("status", response.getStatus());
+
+            if (response.getPayload() != null) {
+                out.set("payload", JSON_MAPPER.valueToTree(response.getPayload()));
+            } else {
+                out.putNull("payload");
+            }
+
+            return JSON_MAPPER.writeValueAsString(out);
+
+        } catch (Exception e) {
+            log.error("Ошибка при обработке JSON-сообщения", e);
+            return buildErrorJson("Unknown", null, WireCodes.Status.INTERNAL_ERROR,
+                    "INTERNAL_ERROR", "Внутренняя ошибка сервера");
+        }
+    }
+
+    // --- helper'ы ---
+
+    private static String getTextOrNull(JsonNode node, String field) {
+        if (node == null || !node.has(field) || node.get(field).isNull()) return null;
+        return node.get(field).asText();
+    }
+
+    /**
+     * Генерация JSON-ошибки в формате ответа:
+     * {
+     *   "op": op,
+     *   "requestId": requestId,
+     *   "status": status,
+     *   "payload": {
+     *     "code": errorCode,
+     *     "message": errorMessage
+     *   }
+     * }
+     */
+    private static String buildErrorJson(String op,
+                                         String requestId,
+                                         int status,
+                                         String errorCode,
+                                         String errorMessage) {
+        try {
+            ObjectNode root = JSON_MAPPER.createObjectNode();
+
+            if (op != null) root.put("op", op); else root.putNull("op");
+            if (requestId != null) root.put("requestId", requestId); else root.putNull("requestId");
+
+            root.put("status", status);
+
+            ObjectNode payload = root.putObject("payload");
+            payload.put("code", errorCode);
+            payload.put("message", errorMessage);
+
+            return JSON_MAPPER.writeValueAsString(root);
+        } catch (Exception e) {
+            return "{\"op\":\"" + (op != null ? op : "") +
+                    "\",\"requestId\":\"" + (requestId != null ? requestId : "") +
+                    "\",\"status\":" + status +
+                    ",\"payload\":{\"code\":\"" + errorCode +
+                    "\",\"message\":\"" + errorMessage + "\"}}";
+        }
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/Auth/NetAuthSessionNewStep1Request.java

@@ -0,0 +1,14 @@
+package server.logic.ws_protocol.JSON.entyties.Auth;
+
+import server.logic.ws_protocol.JSON.entyties.NetRequest;
+
+public class NetAuthSessionNewStep1Request extends NetRequest {
+    private String login;
+
+    public String getLogin() {
+        return login;
+    }
+    public void setLogin(String login) {
+        this.login = login;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/Auth/NetAuthSessionNewStep1Response.java

@@ -0,0 +1,14 @@
+package server.logic.ws_protocol.JSON.entyties.Auth;
+
+import server.logic.ws_protocol.JSON.entyties.NetResponse;
+
+public class NetAuthSessionNewStep1Response extends NetResponse {
+    private String sessionPwd;
+
+    public String getSessionPwd() {
+        return sessionPwd;
+    }
+    public void setSessionPwd(String sessionPwd) {
+        this.sessionPwd = sessionPwd;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/Auth/NetSessionRefreshRequest.java

@@ -0,0 +1,34 @@
+package server.logic.ws_protocol.JSON.entyties.Auth;
+
+import server.logic.ws_protocol.JSON.entyties.NetRequest;
+
+/**
+ * Запрос SessionRefresh.
+ *
+ * JSON (payload):
+ * {
+ *   "sessionId": 123,
+ *   "sessionPwd": "abcd..."
+ * }
+ */
+public class NetSessionRefreshRequest extends NetRequest {
+
+    private long sessionId;
+    private String sessionPwd;
+
+    public long getSessionId() {
+        return sessionId;
+    }
+
+    public void setSessionId(long sessionId) {
+        this.sessionId = sessionId;
+    }
+
+    public String getSessionPwd() {
+        return sessionPwd;
+    }
+
+    public void setSessionPwd(String sessionPwd) {
+        this.sessionPwd = sessionPwd;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/Auth/NetSessionRefreshResponse.java

@@ -0,0 +1,12 @@
+package server.logic.ws_protocol.JSON.entyties.Auth;
+
+import server.logic.ws_protocol.JSON.entyties.NetResponse;
+
+/**
+ * Успешный ответ на SessionRefresh.
+ *
+ * Дополнительных полей нет, достаточно status=200 и (опционально) пустого payload.
+ */
+public class NetSessionRefreshResponse extends NetResponse {
+    // Ничего дополнительного, вся информация в status.
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/NetEvent.java

@@ -0,0 +1,41 @@
+package server.logic.ws_protocol.JSON.entyties;
+
+/**
+ * Базовый класс для всех событий (event).
+ * Общие поля: op и payload.
+ *
+ * Формат JSON (event):
+ * {
+ *   "op": "...",
+ *   "payload": { ... }
+ * }
+ */
+public abstract class NetEvent {
+
+    /** Имя операции / события (op). */
+    private String op;
+
+    /**
+     * Произвольные данные.
+     * В JSON это поле "payload".
+     */
+    private Object payload;
+
+    // --- getters / setters ---
+
+    public String getOp() {
+        return op;
+    }
+
+    public void setOp(String op) {
+        this.op = op;
+    }
+
+    public Object getPayload() {
+        return payload;
+    }
+
+    public void setPayload(Object payload) {
+        this.payload = payload;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/NetExceptionResponse.java

@@ -0,0 +1,14 @@
+package server.logic.ws_protocol.JSON.entyties;
+
+/**
+ * Ответ с ошибкой (любой отказ).
+ *
+ * В payload лежит:
+ * {
+ *   "code": "...",
+ *   "message": "..."
+ * }
+ */
+public class NetExceptionResponse extends NetResponse {
+    // Ничего дополнительного: код/текст ошибки лежат в payload (Map или DTO).
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/NetRequest.java

@@ -0,0 +1,29 @@
+package server.logic.ws_protocol.JSON.entyties;
+
+/**
+ * Базовый класс для всех запросов (client → server).
+ *
+ * Наследуется от NetEvent и добавляет requestId.
+ *
+ * Формат JSON (request):
+ * {
+ *   "op": "...",
+ *   "requestId": "...",
+ *   "payload": { ... }
+ * }
+ */
+public abstract class NetRequest extends NetEvent {
+
+    /** Идентификатор запроса, чтобы связать запрос и ответ. */
+    private String requestId;
+
+    // --- getters / setters ---
+
+    public String getRequestId() {
+        return requestId;
+    }
+
+    public void setRequestId(String requestId) {
+        this.requestId = requestId;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/NetResponse.java

@@ -0,0 +1,34 @@
+package server.logic.ws_protocol.JSON.entyties;
+
+/**
+ * Базовый класс для всех ответов (server → client).
+ *
+ * Наследуется от NetRequest и добавляет status.
+ *
+ * Формат JSON (response):
+ * {
+ *   "op": "...",
+ *   "requestId": "...",
+ *   "status": 200,
+ *   "payload": { ... } // и для успеха, и для ошибки
+ * }
+ */
+public abstract class NetResponse extends NetRequest {
+
+    /** Статус результата (200 — успех, любое другое значение — ошибка). */
+    private int status;
+
+    // --- getters / setters ---
+
+    public int getStatus() {
+        return status;
+    }
+
+    public void setStatus(int status) {
+        this.status = status;
+    }
+
+    public boolean isOk() {
+        return status == 200;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/tempToTest/NetAddUserRequest.java

@@ -0,0 +1,76 @@
+package server.logic.ws_protocol.JSON.entyties.tempToTest;
+
+import server.logic.ws_protocol.JSON.entyties.NetRequest;
+
+/**
+ * Запрос AddUser.
+ *
+ * Ожидаемый JSON:
+ * {
+ *   "op": "AddUser",
+ *   "requestId": "...",
+ *   "login": "...",
+ *   "loginId": 123,
+ *   "bchId": 456,
+ *   "pubkey0": "...",
+ *   "pubkey1": "...",
+ *   "bchLimit": 1000
+ * }
+ */
+public class NetAddUserRequest extends NetRequest {
+
+    private String login;
+    private long loginId;
+    private long bchId;
+    private String pubkey0;
+    private String pubkey1;
+    private Integer bchLimit;
+
+    public String getLogin() {
+        return login;
+    }
+
+    public void setLogin(String login) {
+        this.login = login;
+    }
+
+    public long getLoginId() {
+        return loginId;
+    }
+
+    public void setLoginId(long loginId) {
+        this.loginId = loginId;
+    }
+
+    public long getBchId() {
+        return bchId;
+    }
+
+    public void setBchId(long bchId) {
+        this.bchId = bchId;
+    }
+
+    public String getPubkey0() {
+        return pubkey0;
+    }
+
+    public void setPubkey0(String pubkey0) {
+        this.pubkey0 = pubkey0;
+    }
+
+    public String getPubkey1() {
+        return pubkey1;
+    }
+
+    public void setPubkey1(String pubkey1) {
+        this.pubkey1 = pubkey1;
+    }
+
+    public Integer getBchLimit() {
+        return bchLimit;
+    }
+
+    public void setBchLimit(Integer bchLimit) {
+        this.bchLimit = bchLimit;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/entyties/tempToTest/NetAddUserResponse.java

@@ -0,0 +1,11 @@
+package server.logic.ws_protocol.JSON.entyties.tempToTest;
+
+import server.logic.ws_protocol.JSON.entyties.NetResponse;
+
+/**
+ * Успешный ответ на AddUser.
+ * Дополнительных полей нет — достаточно status=200.
+ */
+public class NetAddUserResponse extends NetResponse {
+    // Можно потом добавить какие-то данные, если понадобится.
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/JsonMessageHandler.java

@@ -0,0 +1,19 @@
+package server.logic.ws_protocol.JSON.handlers;
+
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.NetRequest;
+import server.logic.ws_protocol.JSON.entyties.NetResponse;
+
+/**
+ * Общий интерфейс для всех JSON-хэндлеров.
+ */
+public interface JsonMessageHandler {
+
+    /**
+     * Обработать запрос и вернуть ответ.
+     *
+     * @param request распарсенный запрос
+     * @param ctx     контекст текущего WebSocket-соединения
+     */
+    NetResponse handle(NetRequest request, ConnectionContext ctx) throws Exception;
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/NetAddUserHandler.java

@@ -0,0 +1,98 @@
+package server.logic.ws_protocol.JSON.handlers.auth;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.tempToTest.NetAddUserRequest;
+import server.logic.ws_protocol.JSON.entyties.tempToTest.NetAddUserResponse;
+import server.logic.ws_protocol.JSON.entyties.NetExceptionResponse;
+import server.logic.ws_protocol.JSON.entyties.NetRequest;
+import server.logic.ws_protocol.JSON.entyties.NetResponse;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.dao.SolanaUsersDAO;
+import shine.db.entities.SolanaUser;
+
+import java.sql.SQLException;
+import java.util.Map;
+
+/**
+ * Временный Хэндлер AddUser.              Используется для тестовой регистрации!!!!!!!!
+ *
+ * Логика:
+ *  - берём login, loginId, bchId, pubkey0, pubkey1, bchLimit;
+ *  - создаём SolanaUser и вставляем через SolanaUsersDAO;
+ *  - если всё ОК → NetAddUserResponse со статусом 200;
+ *  - если ошибка БД или некорректные данные → NetExceptionResponse.
+ */
+public class NetAddUserHandler implements JsonMessageHandler {
+
+    private static final Logger log = LoggerFactory.getLogger(NetAddUserHandler.class);
+
+    @Override
+    public NetResponse handle(NetRequest baseRequest, ConnectionContext ctx) throws Exception {
+        NetAddUserRequest req = (NetAddUserRequest) baseRequest;
+
+        // Минимальная валидация входных данных
+        if (req.getLogin() == null || req.getLogin().isBlank()) {
+            return buildError(req, WireCodes.Status.BAD_REQUEST,
+                    "BAD_LOGIN", "Пустой логин");
+        }
+        if (req.getPubkey0() == null || req.getPubkey0().isBlank()
+                || req.getPubkey1() == null || req.getPubkey1().isBlank()) {
+            return buildError(req, WireCodes.Status.BAD_REQUEST,
+                    "BAD_PUBKEY", "Публичные ключи не указаны");
+        }
+        if (req.getBchLimit() == null) {
+            return buildError(req, WireCodes.Status.BAD_REQUEST,
+                    "BAD_BCH_LIMIT", "Не указан лимит блокчейна");
+        }
+
+        try {
+            SolanaUsersDAO dao = SolanaUsersDAO.getInstance();
+
+            SolanaUser user = new SolanaUser(
+                    req.getLoginId(),
+                    req.getLogin(),
+                    req.getBchId(),
+                    req.getPubkey0(),
+                    req.getPubkey1(),
+                    req.getBchLimit()
+            );
+
+            dao.insert(user);
+
+            NetAddUserResponse resp = new NetAddUserResponse();
+            resp.setOp(req.getOp());
+            resp.setRequestId(req.getRequestId());
+            resp.setStatus(WireCodes.Status.OK);
+            resp.setPayload(null); // можно поставить Map.of("ok", true)
+            log.info("✅ Пользователь добавлен: login={}, loginId={}", req.getLogin(), req.getLoginId());
+            return resp;
+
+        } catch (SQLException e) {
+            log.error("❌ Ошибка при вставке пользователя в БД", e);
+            return buildError(req, WireCodes.Status.SERVER_DATA_ERROR,
+                    "DB_ERROR", "Ошибка доступа к базе данных");
+        } catch (Exception e) {
+            log.error("❌ Неожиданная ошибка в AddUser", e);
+            return buildError(req, WireCodes.Status.INTERNAL_ERROR,
+                    "INTERNAL_ERROR", "Внутренняя ошибка сервера");
+        }
+    }
+
+    private NetExceptionResponse buildError(NetRequest req,
+                                            int status,
+                                            String code,
+                                            String message) {
+        NetExceptionResponse resp = new NetExceptionResponse();
+        resp.setOp(req.getOp());
+        resp.setRequestId(req.getRequestId());
+        resp.setStatus(status);
+        resp.setPayload(Map.of(
+                "code", code,
+                "message", message
+        ));
+        return resp;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/NetAuthSessionNewStep1Handler.java

@@ -0,0 +1,79 @@
+package server.logic.ws_protocol.JSON.handlers.auth;
+
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.*;
+import server.logic.ws_protocol.JSON.entyties.Auth.NetAuthSessionNewStep1Request;
+import server.logic.ws_protocol.JSON.entyties.Auth.NetAuthSessionNewStep1Response;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.dao.SolanaUsersDAO;
+import shine.db.entities.SolanaUser;
+
+import java.security.SecureRandom;
+import java.util.Map;
+
+public class NetAuthSessionNewStep1Handler implements JsonMessageHandler {
+
+    private static final SecureRandom RANDOM = new SecureRandom();
+
+    @Override
+    public NetResponse handle(NetRequest baseReq, ConnectionContext ctx) throws Exception {
+
+        NetAuthSessionNewStep1Request req = (NetAuthSessionNewStep1Request) baseReq;
+
+        String login = req.getLogin();
+        if (login == null || login.isBlank()) {
+            return error(req, WireCodes.Status.BAD_REQUEST,
+                    "EMPTY_LOGIN", "Пустой логин");
+        }
+
+        // 1) Проверка: в контексте никто не авторизован
+        if (ctx.getLogin() != null) {
+            return error(req, WireCodes.Status.BAD_REQUEST,
+                    "ALREADY_AUTHED",
+                    "Попытка повторной авторификации для уже заданного login=" + ctx.getLogin());
+        }
+
+        // 2) Ищем пользователя в локальной БД
+        SolanaUser solanaUser = SolanaUsersDAO.getInstance().getByLogin(login);
+
+        if (solanaUser == null) {
+            // TODO позже — запрос в Solana, если не нашли локально
+            return error(req, WireCodes.Status.UNVERIFIED,
+                    "UNKNOWN_USER", "Пользователь с таким логином не найден");
+        }
+
+        // 3) Заполняем контекст полями пользователя
+        ctx.setLogin(solanaUser.getLogin());
+        ctx.setLoginId(solanaUser.getLoginId());
+        ctx.setBchId(solanaUser.getBchId());
+        ctx.setPubkey0(solanaUser.getPubkey0());
+        ctx.setPubkey1(solanaUser.getPubkey1());
+        ctx.setBchLimit(solanaUser.getBchLimit());
+
+        // 4) Генерируем надёжный sessionPwd
+        // SecureRandom + время → достаточно
+        String sessionPwd = Long.toHexString(System.nanoTime()) +
+                Long.toHexString(RANDOM.nextLong());
+
+        ctx.setSessionPwd(sessionPwd);
+
+        // 5) Формируем ответ
+        NetAuthSessionNewStep1Response resp = new NetAuthSessionNewStep1Response();
+        resp.setOp(req.getOp());
+        resp.setRequestId(req.getRequestId());
+        resp.setStatus(WireCodes.Status.OK);
+        resp.setPayload(Map.of("sessionPwd", sessionPwd));
+
+        return resp;
+    }
+
+    private NetExceptionResponse error(NetRequest req, int status, String code, String msg) {
+        NetExceptionResponse resp = new NetExceptionResponse();
+        resp.setOp(req.getOp());
+        resp.setRequestId(req.getRequestId());
+        resp.setStatus(status);
+        resp.setPayload(Map.of("code", code, "message", msg));
+        return resp;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/NetSessionRefreshHandler.java

@@ -0,0 +1,94 @@
+package server.logic.ws_protocol.JSON.handlers.auth;
+
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.NetExceptionResponse;
+import server.logic.ws_protocol.JSON.entyties.NetRequest;
+import server.logic.ws_protocol.JSON.entyties.NetResponse;
+import server.logic.ws_protocol.JSON.entyties.Auth.NetSessionRefreshRequest;
+import server.logic.ws_protocol.JSON.entyties.Auth.NetSessionRefreshResponse;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.dao.ActiveSessionsDAO;
+import shine.db.entities.ActiveSession;
+
+import java.sql.SQLException;
+import java.util.Map;
+
+/**
+ * Хэндлер SessionRefresh.
+ *
+ * Логика:
+ *  - берём sessionId и sessionPwd из запроса;
+ *  - ищем сессию в БД;
+ *  - если не нашли или пароль не совпал → NetExceptionResponse;
+ *  - если всё ок:
+ *      * обновляем ConnectionContext (sessionId, sessionPwd, статус USER);
+ *      * возвращаем NetSessionRefreshResponse со статусом 200.
+ */
+public class NetSessionRefreshHandler implements JsonMessageHandler {
+
+    @Override
+    public NetResponse handle(NetRequest request, ConnectionContext ctx) throws Exception {
+        NetSessionRefreshRequest req = (NetSessionRefreshRequest) request;
+
+        long sessionId = req.getSessionId();
+        String sessionPwd = req.getSessionPwd();
+
+        if (sessionPwd == null || sessionPwd.isEmpty()) {
+            return buildError(req, WireCodes.Status.BAD_REQUEST,
+                    "BAD_SESSION_PWD", "Пустой пароль сессии");
+        }
+
+        ActiveSessionsDAO dao = ActiveSessionsDAO.getInstance();
+        ActiveSession session;
+        try {
+            session = dao.getBySessionId(sessionId);
+        } catch (SQLException e) {
+            // Ошибка БД → внутренняя ошибка сервера
+            return buildError(req, WireCodes.Status.SERVER_DATA_ERROR,
+                    "DB_ERROR", "Ошибка доступа к базе данных");
+        }
+
+        if (session == null) {
+            return buildError(req, WireCodes.Status.UNVERIFIED,
+                    "SESSION_NOT_FOUND", "Сессия не найдена");
+        }
+
+        String dbPwd = session.getSessionPwd();
+        if (dbPwd == null || !dbPwd.equals(sessionPwd)) {
+            return buildError(req, WireCodes.Status.UNVERIFIED,
+                    "SESSION_PWD_MISMATCH", "Неверный пароль сессии");
+        }
+
+        // Всё хорошо — обновляем контекст соединения
+        if (ctx != null) {
+            ctx.setSessionId(sessionId);
+            ctx.setSessionPwd(sessionPwd);
+            // Если потом добавишь в ActiveSession login / loginId — можно здесь и их проставлять
+            ctx.setAuthenticationStatus(ConnectionContext.AUTH_STATUS_USER);
+        }
+
+        // И возвращаем OK без доп. данных
+        NetSessionRefreshResponse resp = new NetSessionRefreshResponse();
+        resp.setOp(req.getOp());
+        resp.setRequestId(req.getRequestId());
+        resp.setStatus(WireCodes.Status.OK);
+        resp.setPayload(null); // или Map.of("ok", true)
+        return resp;
+    }
+
+    private NetExceptionResponse buildError(NetRequest req,
+                                            int status,
+                                            String code,
+                                            String message) {
+        NetExceptionResponse resp = new NetExceptionResponse();
+        resp.setOp(req.getOp());
+        resp.setRequestId(req.getRequestId());
+        resp.setStatus(status);
+        resp.setPayload(Map.of(
+                "code", code,
+                "message", message
+        ));
+        return resp;
+    }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/Описание протокола.md

@@ -0,0 +1,52 @@
+Протокол использует единый формат JSON-сообщений: клиент всегда отправляет запросы с полями op, requestId и payload, сервер отвечает тем же op и requestId, добавляя status (200 для успеха, любое другое значение — ошибка) и либо payload, либо error. 
+
+События от сервера приходят без requestId и status, содержат только op и payload и не являются ответами на запросы.
+
+# Примеры JSON для SearchUsers (минимальная шпаргалка)
+
+## 🔵 Запрос (client → server)
+
+```json
+{
+  "op": "SearchUsers",
+  "requestId": "req-1",
+  "payload": {
+    "query": "ai"
+  }
+}
+
+🟢 Успешный ответ (server → client)
+
+{
+  "op": "SearchUsers",
+  "requestId": "req-1",
+  "status": 200,
+  "payload": {
+    "users": [
+      { "login": "aidar" },
+      { "login": "anya" }
+    ]
+  }
+}
+
+🔴 Ошибочный ответ (server → client)
+
+{
+  "op": "SearchUsers",
+  "requestId": "req-1",
+  "status": 403,
+  "error": {
+    "code": "SESSION_EXPIRED",
+    "message": "Сессия истекла"
+  }
+}
+
+🟣 Событие (server → client, не ответ)
+
+{
+  "op": "NewBlockEvent",
+  "payload": {
+    "blockchainId": 42,
+    "blockNumber": 101
+  }
+}

shine-server-net-protocol/src/main/java/server/logic/ws_protocol/WireCodes.java

@@ -0,0 +1,102 @@
+package server.logic.ws_protocol;
+
+/**
+ * WireCodes — константы бинарного протокола поверх WebSocket.
+ *
+ * Формат входящего сообщения:
+ *   [4] int opCode (big-endian)
+ *   [*] payload
+ *
+ * Ответ сервера:
+ *   ровно [4] int statusCode (big-endian)
+ */
+public final class WireCodes {
+    private WireCodes() {}
+
+    public static final class Op {
+        public static final int PING      = 0;
+        public static final int ADD_BLOCK = 1;
+        public static final int GET_BLOCKCHAIN = 2;
+        public static final int SEARCH_USERS = 30;
+        public static final int GET_LAST_BLOCK_INFO = 31;
+        private Op() {}
+    }
+
+    public static final class Status {
+        public static final int PONG           = 100; // ответ на PING
+//        public static final int OK             = 200; // успех
+
+        public static final int ALREADY_EXISTS = 409; // пришёл блок < N+1
+        public static final int NON_SEQUENTIAL = 412; // пришёл блок > N+1
+
+
+        private Status() {}
+
+
+
+
+        // ============================================================
+        // 🟢 УСПЕШНЫЕ ОПЕРАЦИИ
+        // ============================================================
+
+        /** ✅ Блок успешно добавлен в цепочку. */
+        public static final int OK = 200;
+
+        /** 🌱 Создана новая цепочка (первый блок-заголовок принят). */
+        public static final int CHAIN_CREATED = 201;
+
+        /**
+         * 🔁 Такой блок уже существует.
+         * Клиент может считать это успешным ответом:
+         *  - сервер возвращает 8 байт: [4] код (202) + [4] номер последнего блока (int)
+         *  - клиент обновляет свой lastBlockNumber и не пересылает этот блок снова.         */
+        public static final int BLOCK_ALREADY_EXISTS = 202;  // плюс к кодуследом возвращается номер последнего блока на сервере
+
+
+        // ============================================================
+        // 🟡 ЛОГИЧЕСКИЕ / ПРОТОКОЛЬНЫЕ ОШИБКИ
+        // ============================================================
+
+        /** ⚠️ Нарушена последовательность — пришёл блок с номером > ожидаемого.
+         *  Сервер вернёт 8 байт: [4] код (409) + [4] последний номер блока.
+         *  Клиент должен дослать недостающие блоки.         */
+        public static final int OUT_OF_SEQUENCE = 409; // плюс к кодуследом возвращается номер последнего блока на сервере
+
+        /** ❌ Некорректные или неполные данные в запросе. */
+        public static final int BAD_REQUEST = 400;
+
+        /** 🚫 Цепочка с указанным blockchainId не найдена. */
+        public static final int CHAIN_NOT_FOUND = 404;
+
+        /** 🧩 Несовпадение blockchainId между заголовком блока и телом. */
+        public static final int INVALID_BLOCKCHAIN_ID = 421;
+
+        /** ❌ Ошибка верификации блока — хэш или подпись не совпали.
+        * 🔐 Ошибка хэша: SHA-256(preimage) не совпал с переданным hash32.
+        * 🔏 Ошибка подписи Ed25519 — блок не прошёл криптографическую проверку. */
+        public static final int UNVERIFIED = 422;
+
+
+        /** 🙅 Некорректный логин (пустой, неверный формат, недопустимые символы). По сути вообще не может быть, тк логин проверяют при создании в другом блокчейне*/
+        public static final int BAD_LOGIN = 462;
+
+
+        // ============================================================
+        // 🔴 СИСТЕМНЫЕ ОШИБКИ / ОГРАНИЧЕНИЯ
+        // ============================================================
+
+        // ============================================================
+        // 🔴 СИСТЕМНЫЕ ОШИБКИ / ОГРАНИЧЕНИЯ
+        // ============================================================
+
+        /** 💾 Достигнут лимит размера блокчейна. */
+        public static final int BLOCKCHAIN_FULL = 507;
+
+        /** 🧱 Ошибка при сохранении или обновлении данных на сервере (файлы, JSON и т.п.). */
+        public static final int SERVER_DATA_ERROR = 501;
+
+        /** 💥 Общая внутренняя ошибка сервера (необработанное исключение). */
+        public static final int INTERNAL_ERROR = 500;
+    }
+
+}

shine-server-net-protocol/src/main/java/Мини памятка по классам джисон протокола.md

@@ -0,0 +1,29 @@
+Мини-памятка по JSON-протоколу 
+**     JsonInboundProcessor
+
+Центральный вход для JSON.
+Принимает текст → парсит → ищет op → создаёт нужный NetRequest → вызывает хэндлер → возвращает JSON-ответ.
+
+**     JsonHandlerRegistry
+
+Словарь операций.
+Связывает op → requestClass и op → handler.
+Любая новая операция регистрируется здесь.
+
+**     NetEvent / NetRequest / NetResponse
+
+Базовые структуры JSON-протокола - от которых есть реализации для всех сущностей запросов ответов
+
+**     ConnectionContext
+
+Хранит состояние текущего WebSocket-соединения: логин, sessionId, статус пользователя.
+Передаётся в любой JSON-хэндлер.
+
+**     JsonMessageHandler
+
+Интерфейс одного хэндлера JSON-операции:        - от которого наследуются все хэндлеры обработчики запросов
+handle(request, context) → NetResponse.
+
+**     WebSocket endpoint
+
+BlockchainWsEndpoint.onText(...) получает строку → передаёт в JsonInboundProcessor → отправляет клиенту готовый JSON-ответ.

shine-server-net-server/build.gradle

@@ -0,0 +1,36 @@
+plugins {
+    id 'java'
+}
+
+group = 'shine'
+version = '1.0.0'
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation project(':shine-server-config')  // модуль с настройками
+    implementation project(':shine-server-net-protocol')
+
+    // Jackson для JSON
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.0'
+
+    // SLF4J API (если у тебя уже тянется из корня / других модулей, можно убрать)
+    implementation 'org.slf4j:slf4j-api:2.0.13'
+
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+
+

src/main/docs/Запуск на сервере.txt

@@ -0,0 +1,10 @@
+
+просто запустить
+user@p628065:~/docker/ws-server$ java -jar ws-server.jar
+
+
+запустить нормально что бы в фоне работал
+user@p628065:~/docker/ws-server$ nohup java -jar ws-server.jar > server.log 2>&1 &
+
+перестартовать кадди
+user@p628065:~/docker/ws-server$ docker restart caddy

src/main/docs/План работ до мвп/ДАО.md

@@ -0,0 +1,13 @@
+Для того что бы работало ДАО SHiNE.DAO
+
+Зарегить в дао в солане.
+    Что бы в нём работало голосование на
+        Перевод средств.
+        Выдача лимита раздававть бонусы. 
+        На апдейт смарт кантрактов 
+        И посути на запуск любой программы в сол.
+
+
+
+
+

src/main/docs/План работ до мвп/Инвестиции.md

@@ -0,0 +1,67 @@
+Инвестиции считаем в USDT а вносим и выносим просто в соланах поо текущему курсу из оракула
+
+НИКАНИХ замороженных NFT токенов валют и т.д.
+
+Просто записи об очереди и вызов только через наш сайт!!   //(И страницу дозаписи можно сделать фикированной в ARVEAVE) 
+
+Храним в одном пда реестре:
+    сколько сколько сейчас в очереди записей, 
+    на какую сумму 
+    адрес последней записи.
+        (Адрес записи-инвестиции это имя пользователя и номер записи)
+    а так же сколько уже выплаченно
+
+
+
+
+
+                Создание новой записи о инвестициях.
+
+На каждого Пользователя-инвестора заводим вначале новый ПДА
+    , а если он уже есть то просто увеличиваем размер старово ПДА и делаем дозапись
+
+** В записи у пользователя храним. 
+    Её номер (то есть сколько до неё), 
+    Сумму в очереди до неё,
+    Флаг что выплаченно
+    Адрес СЛЕДУЮЩИЙ транцакции
+
+
+** Есть акаун реестр где указано сколько уже есть записей, на какую сумму и какой номер крайнейй записи
+
+** И есть акаунт реестр на выплаты, в нём указано 
+    сколько по счёту записей уже выплаченно 
+    и на какую сумму уже выплаченно 
+    сколько USDT надо накопить на для следующей выплаты
+    адрес (акаунт и номер записи)
+
+** И вторая очеред для самых близких
+    Там всё тоже самое что и в первой только суммы выплаты больше и даты непонятны
+
+                Полуается 
+** добавить запись
+    Прочитал главный реестр, 
+    И пда с крайней записью.
+    Попробывал прочитать пда в который надо писать новую запись
+        И дальше либо создал его или увеличил его размер на 1 запись
+        И записал в него данные 
+    А в преведущую крайнюю запись добавил адрес следующей записи
+    Обновил данные в реестре
+
+** Прочитать данные для пользователя
+    Прочитал Все записи из его пда
+    Прочитал Сколько выплаченно прочитал из реестра на выплату
+    Прочитал Сколько сейчас уже есть денег и сколько надо до следующей выплаты
+    Пересчитал данные и показал пользователю в виде актуальной таблицы
+
+** Сама выплата 
+    всё можно легко понять по аналогии с тем что выше написанно  
+
+    
+    
+    
+
+
+
+
+    

src/main/docs/План работ до мвп/Правила получения новых акаунтов.md

@@ -0,0 +1,4 @@
+(При создании новых пользователей вообще не гоним о том что может быть конфликт если два чел в раз попытаются за регистрироваться 
+т.к. даже при средней скорости 1 зарегистрированный чел в минуту будеит уже 43 200/мес,)
+
+Поэтому делаем всю регистрацию одной транзакцией!! и не тупим пока об этом  !!! 

src/main/docs/План работ до мвп/Функции в Solana.md

@@ -0,0 +1,29 @@
+
+
+
+Зарегистрироваться
+
+
+Внести инвестиции (получить запись на бонус в 1 очередь) 
+
+Выдать (Записать комуто) бонус 1 очереди
+Выдать (Записать комуто)  бонус второй очереди
+
+Попробывать сделать шаг выплаты по очереди
+
+Функции чтения
+    Получить данные о пользователе
+    Получить данные о пользователе(по логину, тоетсь по логину узнали ИД  потом по ИД данные о пользователе)
+    Получить данные об очереди выплат пользователя
+
+Данные о пользователе по ИД подписанны ЦП пользователя (прямо в блокчейне!!)
+
+
+
+
+На одного пользователя храниться 2-3 пда  
+    ПДА ссылка по имени пользователя на ИД ПОльзователя
+    ПДА по ИД пользователя со всеми его данными
+            (И просто дописывать данные о каждом новом Bch пользователя иего пда по userИД)
+    
+    

src/main/docs/Принципы сияния/Кто есть сияющие(5 пунктов).md

@@ -0,0 +1,27 @@
+                                                    07.11.2025г.
+        Принципы сияющих людей.
+То что в соц сети можно постаить галочку что я Сияющий или воздержаться
+
+1. `Не Врать / Не обманывать`
+   (Соответственно все данные и оценки и высказывания этого человека будут должны бытьверными)
+
+2. `Развиваться`
+   (Соответствено должны появляться записи о пройденных курсах)
+
+3. `Верить в духовное (что есть что то большее чем только физическое тело)`
+    (По этому человек соглашается (не спорит) что есть духовные практики, и проходит курсы и практики духовные)
+
+4. `Социальная ответственность. Понимание того что мы часть единой цивилизации`
+   то что человек поддерживает: экологические, социальные, светлые начинания и т.д.
+   (Соответственно в соц сети. Отчёты о действиях, переводы, подтверждениедругими что ты делаешь)
+
+5. `Отсноситься кдругим таккак ты хочешь что бы относились к тебе.` 
+   И то что люди тебя так ценят.
+   (В соц сетиважно как оценивают тебя люди из твоего круга) (И можно написать как ты относишмся к людям и как хочешь что бы относились к тебе - это один пункт)
+
+    Друзья как ты. Ты как друзья.
+    Друзей оценивают по тебе. Тебя оценивают по друзьям.
+   
+
+
+

src/main/docs/Формат блоков/Описанией записей/Начало блокчейна.md

@@ -0,0 +1,45 @@
+* ============================================================================
+* HeaderBody — тело записи типа 0 (заглавие блокчейна)
+* ============================================================================
+*
+* 🧩 Назначение:
+*   Первый блок каждой пользовательской цепочки (.bch) — это "заголовок".
+*   Он хранит базовую информацию о владельце, версии и публичном ключе.
+*
+*   Этот блок всегда имеет:
+*     • recordType = 0
+*     • recordNumber = 0
+*     • recordTypeVersion = 1
+*
+* ----------------------------------------------------------------------------
+* 🔹 Формат body (без общих 20 байт заголовка блока BchBlock)
+*
+* | Смещение | Размер | Поле                | Формат | Описание |
+* |-----------|--------|--------------------|---------|-----------|
+* | 0x00      | 8      | tag                | ASCII   | Статическая сигнатура "SHiNE001" |
+* 
+* | 0x10      | 1      | userLoginLength=N  | uint8   | Длина логина пользователя |
+* | 0x11      | N      | userLogin          | UTF-8   | Логин пользователя |
+
+* | 0x11+N    | 4      | blockchainType     | int BE  | Зарезервировано (всегда 0) |
+
+
+* | 0x08      | 8      | blockchainId       | long BE | Уникальный идентификатор цепочки |
+* | 0x11+N    | 4      | blockchainType     | int BE  | Зарезервировано (всегда 0) |
+* | 0x15+N    | 4      | blockchainNumber   | int BE  | Зарезервировано (всегда 0) |
+* | 0x19+N    | 2      | versionUserBch     | short BE| Версия формата (всегда 1) |
+* | 0x1B+N    | 8      | prevUserBchId      | long BE | Зарезервировано (всегда 0) |
+* | 0x23+N    | 32     | publicKey32        | raw     | Публичный ключ (Ed25519, 32 байта) |
+*
+* ----------------------------------------------------------------------------
+* 💡 Пример структуры в байтах:
+*
+* 0000: 53 48 69 4E 45 30 30 31     "SHiNE001"
+* 0008: 00 00 00 00 01 23 45 67     blockchainId
+* 0010: 05                           userLoginLength = 5
+* 0011: 41 69 64 61 72              userLogin = "Aidar"
+* 0016: 00 00 00 00                 blockchainType = 0
+* 001A: 00 00 00 00                 blockchainNumber = 0
+* 001E: 00 01                       versionUserBch = 1
+* 0020: 00 00 00 00 00 00 00 00     prevUserBchId = 0
+* 0028: [32 байта публичного ключа]

src/main/docs/Формат блоков/Смена Пароля/сама схема смены цп.md

@@ -0,0 +1,49 @@
+Solana говорит актуальные
+userLogin
+userId
+
+Текущий номер блокчейна
+
+И Список Доверенных (userId, дата добавления)
+.. Добавить доверенного
+.. Убавить доверенного
+
+
+------------------------
+И на каждый блокчен  :
+UserBlcId
+UserBlcSig
+UserBlcLimit лимит МБ этого блокчейна
+
+uerId
+Какой это по счёту блокчейн у пользователя
+Ид преведущего блокчейна
+
+-----------------
+        Можно в солане 
+Добавить доверенного 
+Удалить доверенного
+Сменить свою подпись  (приложив строки с подписью доверенных)
+
+И задержка на 30 дней довступления в силу
+(А со старта можно и без задержки главное библиотеку для доступа к сушностям в солане на js сразу генерировать вместе с растом :))
+
+и ещё создать запись для смены ( и пох если зделал то сделал откатить нельзя можнотолько что бы все остальные не голосовали)
+--------------
+
+
+Можно делать технические записи  (они совпадают с соланой)
+
+В самом начале блок №0
+userLogin - userId
+
+блок №1
+UserBlcId - UserBlcSig
+
+
+
+Это чисто записи 
+Добавить доверенного
+Убавить доверенного
+Добавить лимит
+

src/main/docs/Формат блоков/Что пишем в solana.md

@@ -0,0 +1,27 @@
+Первый это ссылка  (Пда по логину, у него двва ключа "login"  и сам логин пользователя (1 байт длинна + логин до 30 символов))
+В логине можно a-z 0-9 и "_"
+
+В нём записано
+    Посути нуден только UserId
+А так можно 
++ вначале 8 байт константа типо ПДА
++ Сам логин с заклавными буквами (не надо)
++ Цп  (не надо)
+
+
+Второй блокчен
+(ПДА по двум ключам??    Ид)
+
+
++ вначале 8 байт константа типо ПДА
++ 1 байт - N длинна логина
++ N байт - сам логин (можно с большими буквами)
+
+
+
+
+
+
+
+
+

src/main/docs/Формат блоков/структура блока/Запись в блокчейн.txt

@@ -0,0 +1,66 @@
+ * ============================================================================
+ *  BchBlockEntry — универсальная запись блокчейна SHiNE (.bch)
+ * ============================================================================
+ *
+ * 🧩 Формат файла .bch:
+ *  Каждый блок хранится последовательно, без промежутков.
+ *  Один блок = «заголовок» (RAW) + подпись (64) + хэш (32).
+ *
+ *  FULL = RAW + signature(64) + hash(32)
+ *
+ * ---------------------------------------------------------------------------
+ *  🔹 Структура RAW-части блока (без подписи и хэша)
+ * ---------------------------------------------------------------------------
+ *  Размеры и порядок строго фиксированы (BigEndian).
+ *
+ *  Порядок байтов (сверху вниз, смещения от начала RAW):
+ *
+ *  ┌────────────────────────────┬────────┬───────────────────────────────┐
+ *  │ Поле                       │ Размер │ Описание                      │
+ *  ├────────────────────────────┼────────┼───────────────────────────────┤
+ *  │ recordSize                 │ 4 байта│ = M + 20 — общий размер RAW   │
+ *  │ recordNumber               │ 4 байта│ порядковый номер блока        │
+ *  │ timestamp                  │ 8 байт │ UNIX time (секунды)           │
+
+ Номер линии 2 байта                                                        линии пока просто пишутся но никак не используются
+ номер преведущего блока в этой линии 4 байа
+
+ //Можно сказать что здесь уже тело пошло
+ *  │ recordType                 │ 2 байта│ тип тела (0=Header, 1=Text)   │
+ *  │ recordTypeVersion          │ 2 байта│ версия структуры данного типа │
+ *  │ body                       │ M байт │ бинарное тело записи          │
+ *  └────────────────────────────┴────────┴───────────────────────────────┘
+ *
+ *  ⇒ RAW_HEADER_SIZE = 4 + 4 + 8 + 2 + 2 = 20 байт.
+ *  ⇒ recordSize = RAW_HEADER_SIZE + body.length
+ *
+ * ---------------------------------------------------------------------------
+ *  🔹 Структура FULL-блока
+ * ---------------------------------------------------------------------------
+ *
+ *  ┌────────────────────────────┬─────────┬──────────────────────────────┐
+ *  │ RAW                        │ M+20    │ тело блока без подписи       │
+ *  │ signature64                │ 64      │ подпись Ed25519(preimage)    │
+ *  │ hash32                     │ 32      │ SHA-256(preimage)            │
+ *  └────────────────────────────┴─────────┴──────────────────────────────┘
+ *
+ *  ⇒ Общая длина FULL = recordSize + 96 байт.
+ *
+ * ---------------------------------------------------------------------------
+ *  🔹 Канонический preimage для подписи/хэша
+ * ---------------------------------------------------------------------------
+ Новый вариант преимадже без блокченй ИД !!
+            так как он может меняться
+
+ *  preimage = Заглавие SHiNE
+ *             userLogin(UTF-8, без длины) +
+ *             userId(8B, BE) +
+ *               можно номер блока?
+ *             prevHash32(32B) +
+ *             rawBytes (M+20B)
+ *
+ *  hash32     = SHA-256(preimage)
+ *  signature64= Ed25519.sign(preimage, privateKey)
+ *
+ *  Проверка осуществляется через {@link utils.crypto.BchCryptoVerifier}.
+

src/main/docs/Формат блоков/структура блока/типы субблокченов.md

@@ -0,0 +1,13 @@
+Технический блокчен
+
+Блоки в солану
+
+Личнык данные
+Связи
+
+
+Публичные сообщения
+
+
+
+Личые письма

src/main/java/CreateNewDatabase.java

@@ -0,0 +1,9 @@
+import shine.db.DatabaseInitializer;
+
+public class CreateNewDatabase {
+
+    public static void main(String[] args) {
+        // Просто прокидываем управление в DatabaseInitializer
+        DatabaseInitializer.createNewDB(args);
+    }
+}

src/main/java/TestJsonWsClient.java

@@ -0,0 +1,106 @@
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.WebSocket;
+import java.net.http.WebSocket.Listener;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CountDownLatch;
+
+public class TestJsonWsClient {
+
+    public static void main(String[] args) throws Exception {
+        String uri = "ws://localhost:7070/ws";
+
+
+        String jsonRequestSessionRefresh = """
+                {
+                  "op": "SessionRefresh",
+                  "requestId": "test-1",
+                  "sessionId": 123,
+                  "sessionPwd": "test-password"
+                }
+                """;
+
+        String jsonRequestAddUser = """
+        {
+          "op": "AddUser",
+          "requestId": "test-add-1",
+          "login": "anya1111",
+          "loginId": 100211,
+          "bchId": 4222,
+          "pubkey0": "PUB0",
+          "pubkey1": "PUB1",
+          "bchLimit": 1000000
+        }
+        """;
+
+        String jsonRequestAuthSessionNewStep1 = """
+                {
+                  "op": "AuthSessionNewStep1",
+                  "requestId": "test-auth-1",
+                  "login": "anya1111"
+                }
+                """;
+
+
+        // Тестовый JSON-пакет SessionRefresh
+        String jsonRequest = jsonRequestAuthSessionNewStep1;
+
+        System.out.println("Подключаемся к " + uri);
+
+        CountDownLatch latch = new CountDownLatch(1);
+
+        HttpClient client = HttpClient.newHttpClient();
+
+        WebSocket webSocket = client.newWebSocketBuilder()
+                .buildAsync(URI.create(uri), new Listener() {
+                    @Override
+                    public void onOpen(WebSocket webSocket) {
+                        System.out.println("✅ WebSocket подключен");
+
+                        // Отправляем JSON сразу после подключения
+                        System.out.println("📤 Отправляем JSON-запрос:");
+                        System.out.println(jsonRequest);
+
+                        webSocket.sendText(jsonRequest, true);
+                        Listener.super.onOpen(webSocket);
+                    }
+
+                    @Override
+                    public CompletionStage<?> onText(WebSocket webSocket,
+                                                     CharSequence data,
+                                                     boolean last) {
+                        String message = data.toString();
+                        System.out.println("📥 Получен TEXT-ответ от сервера:");
+                        System.out.println(message);
+
+                        // После получения первого ответа — закрываем соединение
+                        webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "test done");
+                        latch.countDown();
+                        return Listener.super.onText(webSocket, data, last);
+                    }
+
+                    @Override
+                    public void onError(WebSocket webSocket, Throwable error) {
+                        System.out.println("❌ Ошибка WebSocket-клиента: " + error.getMessage());
+                        error.printStackTrace(System.out);
+                        latch.countDown();
+                    }
+
+
+                    @Override
+                    public CompletionStage<?> onClose(WebSocket webSocket,
+                                                      int statusCode,
+                                                      String reason) {
+                        System.out.println("🔚 Соединение закрыто. Код=" + statusCode + ", причина=" + reason);
+                        latch.countDown();
+                        return Listener.super.onClose(webSocket, statusCode, reason);
+                    }
+                }).join();
+
+        // Ждём, пока получим ответ/ошибку/закрытие
+        latch.await();
+        System.out.println("Тест завершён, выходим.");
+    }
+}

src/main/java/TestJsonWsClient2.java

@@ -0,0 +1,119 @@
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.WebSocket;
+import java.net.http.WebSocket.Listener;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CountDownLatch;
+
+public class TestJsonWsClient2 {
+
+    public static void main(String[] args) throws Exception {
+        String uri = "ws://localhost:7070/ws";
+
+        String jsonRequestSessionRefresh = """
+                {
+                  "op": "SessionRefresh",
+                  "requestId": "test-1",
+                  "sessionId": 123,
+                  "sessionPwd": "test-password"
+                }
+                """;
+
+        String jsonRequestAddUser = """
+                {
+                  "op": "AddUser",
+                  "requestId": "test-add-1",
+                  "login": "anya1111",
+                  "loginId": 100211,
+                  "bchId": 4222,
+                  "pubkey0": "PUB0",
+                  "pubkey1": "PUB1",
+                  "bchLimit": 1000000
+                }
+                """;
+
+        String jsonRequestAuthSessionNewStep1 = """
+                {
+                  "op": "AuthSessionNewStep1",
+                  "requestId": "test-auth-1",
+                  "login": "anya1111"
+                }
+                """;
+
+        // Что тестируем сейчас:
+        String jsonRequest = jsonRequestAuthSessionNewStep1;
+//      String jsonRequest = jsonRequestSessionRefresh;
+//      String jsonRequest = jsonRequestAddUser;
+
+        System.out.println("Подключаемся к " + uri);
+
+        CountDownLatch latch = new CountDownLatch(1);
+
+        HttpClient client = HttpClient.newHttpClient();
+
+        WebSocket webSocket = client.newWebSocketBuilder()
+                .buildAsync(URI.create(uri), new Listener() {
+
+                    // 0 — ещё ничего не получили
+                    // 1 — получили 1-й ответ, отправили повторно
+                    // 2 — получили 2-й ответ, закрываемся
+                    private int responsesCount = 0;
+
+                    @Override
+                    public void onOpen(WebSocket webSocket) {
+                        System.out.println("✅ WebSocket подключен");
+
+                        System.out.println("📤 Отправляем JSON-запрос (1 раз):");
+                        System.out.println(jsonRequest);
+
+                        webSocket.sendText(jsonRequest, true);
+                        Listener.super.onOpen(webSocket);
+                    }
+
+                    @Override
+                    public CompletionStage<?> onText(WebSocket webSocket,
+                                                     CharSequence data,
+                                                     boolean last) {
+                        String message = data.toString();
+                        responsesCount++;
+
+                        System.out.println("📥 Получен TEXT-ответ #" + responsesCount + " от сервера:");
+                        System.out.println(message);
+
+                        if (responsesCount == 1) {
+                            // После первого ответа — отправляем тот же запрос ещё раз
+                            System.out.println("📤 Отправляем JSON-запрос второй раз:");
+                            System.out.println(jsonRequest);
+                            webSocket.sendText(jsonRequest, true);
+                        } else {
+                            // После второго ответа — закрываем соединение
+                            webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "test done");
+                            latch.countDown();
+                        }
+
+                        return Listener.super.onText(webSocket, data, last);
+                    }
+
+                    @Override
+                    public void onError(WebSocket webSocket, Throwable error) {
+                        System.out.println("❌ Ошибка WebSocket-клиента: " + error.getMessage());
+                        error.printStackTrace(System.out);
+                        latch.countDown();
+                    }
+
+                    @Override
+                    public CompletionStage<?> onClose(WebSocket webSocket,
+                                                      int statusCode,
+                                                      String reason) {
+                        System.out.println("🔚 Соединение закрыто. Код=" + statusCode + ", причина=" + reason);
+                        latch.countDown();
+                        return Listener.super.onClose(webSocket, statusCode, reason);
+                    }
+                }).join();
+
+        // Ждём, пока получим ответ/ошибку/закрытие
+        latch.await();
+        System.out.println("Тест завершён, выходим.");
+    }
+}

src/main/java/WsTestClient.java

@@ -0,0 +1,356 @@
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.WebSocket;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.concurrent.*;
+
+public class WsTestClient {
+
+    // ==== Настройки клиента ====
+    static final String WS_URL = "wss://shineup.me/ws";// "ws://localhost:8080/ws";
+
+    // ==== Тестовые параметры ====
+    static final String FIXED_PRIVATE_KEY_STRING = "SHiNE_TEST_FIXED_PRIVATE_KEY_2025";
+    static final long   BLOCKCHAIN_ID   = 351130785469109974L;//777_000_001L;
+    static final int    BLOCKCHAIN_TYPE = 0;
+    static final int    BLOCKCHAIN_NUM  = 0;
+    static final short  VERSION_USER_BCH = 1;
+    static final long   PREV_USER_BCH_ID = 0L;
+    static final String USER_LOGIN = "test_user";
+
+    // ==== Опкоды ====
+    static final int OP_ADD_BLOCK      = 1;
+    static final int OP_GET_BLOCKCHAIN = 2;
+
+    // ==== Статусы ====
+    static final int STATUS_OK             = 200;
+    static final int STATUS_BAD_REQUEST    = 400;
+    static final int STATUS_ALREADY_EXISTS = 409;
+    static final int STATUS_NON_SEQUENTIAL = 412;
+    static final int STATUS_UNVERIFIED     = 422;
+    static final int STATUS_INTERNAL       = 500;
+
+    // ==== Типы блоков ====
+    static final short TYPE_HEADER = 0;
+    static final short TYPE_TEXT   = 1;
+    static final short RECORD_TYPE_VERSION = 1; // Новое поле
+
+    // ==== Константы формата ====
+    static final int SIGNATURE_LEN = 64;
+    static final int HASH_LEN = 32;
+    static final int RAW_HEADER_SIZE = 4 + 4 + 8 + 2 + 2; // Теперь 20 байт
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("=== WsTestClient v1.1 ===");
+
+        byte[] priv32 = HashUtil.sha256(FIXED_PRIVATE_KEY_STRING.getBytes(StandardCharsets.UTF_8));
+        byte[] pub32  = Ed25519Util.derivePublicKey(priv32);
+
+        WsBinaryCollector reader = new WsBinaryCollector();
+        WebSocket ws = HttpClient.newHttpClient()
+                .newWebSocketBuilder()
+                .buildAsync(URI.create(WS_URL), reader)
+                .join();
+        System.out.println("✅ Connected to " + WS_URL);
+
+        // === 1. Создание заглавного блока ===
+        byte[] headerBody = buildHeaderBody(USER_LOGIN, BLOCKCHAIN_ID, BLOCKCHAIN_TYPE, BLOCKCHAIN_NUM,
+                VERSION_USER_BCH, PREV_USER_BCH_ID, pub32);
+
+        long ts = Instant.now().getEpochSecond();
+        byte[] rawHeader = buildRawRecord(0, ts, TYPE_HEADER, RECORD_TYPE_VERSION, headerBody);
+        byte[] fullHeader = signAndPack(rawHeader, USER_LOGIN, BLOCKCHAIN_ID, new byte[32], priv32, pub32);
+
+        byte[] addHeaderMsg = concat(beInt(OP_ADD_BLOCK), beLong(BLOCKCHAIN_ID), fullHeader);
+        int st1 = sendAndReadStatus(ws, addHeaderMsg, reader);
+        System.out.println("ADD HEADER → " + st1 + " (" + statusName(st1) + ")");
+
+        // === 2. Получаем всю цепочку ===
+        ResponseWithPayload chainResp = sendAndReadPayload(ws, concat(beInt(OP_GET_BLOCKCHAIN), beLong(BLOCKCHAIN_ID)), reader);
+        System.out.println("GET_BLOCKCHAIN → " + chainResp.status + " (" + statusName(chainResp.status) + ")");
+        if (chainResp.status != STATUS_OK) return;
+
+        List<BlockParsed> blocks = parseAllBlocks(chainResp.payload);
+        System.out.println("Chain contains " + blocks.size() + " blocks:");
+
+        for (BlockParsed bp : blocks) {
+            printBlock(bp);
+        }
+
+        // === 3. Добавление нового текстового блока ===
+        Scanner sc = new Scanner(System.in, StandardCharsets.UTF_8);
+        System.out.print("\nВведите текст для добавления в блокчейн (Enter — пропустить): ");
+        String text = sc.nextLine().trim();
+        if (!text.isEmpty()) {
+            byte[] lastHash = blocks.isEmpty() ? new byte[32] : blocks.get(blocks.size() - 1).hash32;
+            int nextNum = blocks.isEmpty() ? 0 : (blocks.get(blocks.size() - 1).recordNumber + 1);
+
+            byte[] textBody = text.getBytes(StandardCharsets.UTF_8);
+            byte[] rawText = buildRawRecord(nextNum, Instant.now().getEpochSecond(), TYPE_TEXT, RECORD_TYPE_VERSION, textBody);
+            byte[] fullText = signAndPack(rawText, USER_LOGIN, BLOCKCHAIN_ID, lastHash, priv32, pub32);
+
+            int st2 = sendAndReadStatus(ws, concat(beInt(OP_ADD_BLOCK), beLong(BLOCKCHAIN_ID), fullText), reader);
+            System.out.println("ADD TEXT → " + st2 + " (" + statusName(st2) + ")");
+        }
+
+        ws.sendClose(WebSocket.NORMAL_CLOSURE, "bye").join();
+        System.out.println("=== Done ===");
+    }
+
+    // ==============================================================
+    //                        БЛОКИ
+    // ==============================================================
+
+    static byte[] buildRawRecord(int recordNumber, long timestampSec,
+                                 short recordType, short recordTypeVersion, byte[] body) {
+        int recordSize = RAW_HEADER_SIZE + body.length;
+        ByteBuffer buf = ByteBuffer.allocate(recordSize).order(ByteOrder.BIG_ENDIAN);
+        buf.putInt(recordSize);
+        buf.putInt(recordNumber);
+        buf.putLong(timestampSec);
+        buf.putShort(recordType);
+        buf.putShort(recordTypeVersion);
+        buf.put(body);
+        return buf.array();
+    }
+
+    static byte[] buildHeaderBody(String userLogin, long blockchainId, int blockchainType,
+                                  int blockchainNumber, short versionUserBch,
+                                  long prevUserBchId, byte[] publicKey32) {
+        byte[] tag = "SHiNE001".getBytes(StandardCharsets.US_ASCII);
+        byte[] loginUtf8 = userLogin.getBytes(StandardCharsets.UTF_8);
+        if (loginUtf8.length > 255) throw new IllegalArgumentException("Логин слишком длинный");
+
+        int cap = 8 + 8 + 1 + loginUtf8.length + 4 + 4 + 2 + 8 + 32;
+        ByteBuffer buf = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
+        buf.put(tag);
+        buf.putLong(blockchainId);
+        buf.put((byte) loginUtf8.length);
+        buf.put(loginUtf8);
+        buf.putInt(blockchainType);
+        buf.putInt(blockchainNumber);
+        buf.putShort(versionUserBch);
+        buf.putLong(prevUserBchId);
+        buf.put(publicKey32);
+        return buf.array();
+    }
+
+    static byte[] signAndPack(byte[] rawBytes, String userLogin, long blockchainId,
+                              byte[] prevHash32, byte[] privateKey32, byte[] publicKey32) {
+        byte[] preimage = buildPreimage(userLogin, blockchainId, prevHash32, rawBytes);
+        byte[] hash32 = HashUtil.sha256(preimage);
+        byte[] sig64 = Ed25519Util.sign(preimage, privateKey32);
+        return concat(rawBytes, sig64, hash32);
+    }
+
+    // ==============================================================
+    //                        ПАРСИНГ
+    // ==============================================================
+
+    static class BlockParsed {
+        int recordSize;
+        int recordNumber;
+        long timestamp;
+        short recordType;
+        short recordTypeVersion;
+        byte[] body;
+        byte[] signature64;
+        byte[] hash32;
+    }
+
+    static List<BlockParsed> parseAllBlocks(byte[] file) {
+        List<BlockParsed> out = new ArrayList<>();
+        int p = 0;
+        while (p + 4 <= file.length) {
+            int recordSize = beInt(file, p);
+            int total = recordSize + SIGNATURE_LEN + HASH_LEN;
+            if (p + total > file.length) break;
+
+            ByteBuffer raw = ByteBuffer.wrap(file, p, recordSize).order(ByteOrder.BIG_ENDIAN);
+            BlockParsed bp = new BlockParsed();
+            bp.recordSize = raw.getInt();
+            bp.recordNumber = raw.getInt();
+            bp.timestamp = raw.getLong();
+            bp.recordType = raw.getShort();
+            bp.recordTypeVersion = raw.getShort();
+            int bodyLen = bp.recordSize - RAW_HEADER_SIZE;
+            bp.body = new byte[bodyLen];
+            raw.get(bp.body);
+            bp.signature64 = Arrays.copyOfRange(file, p + recordSize, p + recordSize + SIGNATURE_LEN);
+            bp.hash32 = Arrays.copyOfRange(file, p + recordSize + SIGNATURE_LEN, p + recordSize + SIGNATURE_LEN + HASH_LEN);
+            out.add(bp);
+            p += total;
+        }
+        return out;
+    }
+
+    static void printBlock(BlockParsed b) {
+        System.out.println("------------------------------------------------------------");
+        String ts = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
+                .withZone(ZoneId.systemDefault())
+                .format(Instant.ofEpochSecond(b.timestamp));
+        System.out.printf("num=%d, type=%d, ver=%d, ts=%s, size=%d%n",
+                b.recordNumber, b.recordType, b.recordTypeVersion, ts, b.recordSize);
+
+        if (b.recordType == TYPE_HEADER)
+            printHeaderBody(b.body);
+        else if (b.recordType == TYPE_TEXT)
+            System.out.println("TEXT: " + new String(b.body, StandardCharsets.UTF_8));
+        else
+            System.out.println("UNKNOWN BODY (" + b.body.length + " bytes)");
+
+        System.out.println("hash=" + toHex(b.hash32));
+    }
+
+    static void printHeaderBody(byte[] body) {
+        ByteBuffer buf = ByteBuffer.wrap(body).order(ByteOrder.BIG_ENDIAN);
+        byte[] tag = new byte[8]; buf.get(tag);
+        long id = buf.getLong();
+        int n = Byte.toUnsignedInt(buf.get());
+        byte[] login = new byte[n]; buf.get(login);
+        int type = buf.getInt();
+        int num = buf.getInt();
+        buf.getShort(); buf.getLong(); // version + prev
+        byte[] pub = new byte[32]; buf.get(pub);
+
+        System.out.println("HEADER: login=" + new String(login, StandardCharsets.UTF_8) +
+                ", id=" + id + ", type=" + type + ", num=" + num);
+        System.out.println("(pubkey first 4 bytes: " + toHex(Arrays.copyOf(pub, 4)) + "...)");
+    }
+
+    // ==============================================================
+    //                   Вебсокет и вспомогательные классы
+    // ==============================================================
+
+    static int sendAndReadStatus(WebSocket ws, byte[] payload, WsBinaryCollector reader) {
+        ws.sendBinary(ByteBuffer.wrap(payload), true).join();
+        byte[] resp = reader.collect(ws);
+        if (resp == null || resp.length < 4) throw new IllegalStateException("empty response");
+        return beInt(resp, 0);
+    }
+
+    static class ResponseWithPayload {
+        int status;
+        byte[] payload;
+    }
+
+    static ResponseWithPayload sendAndReadPayload(WebSocket ws, byte[] payload, WsBinaryCollector reader) {
+        ws.sendBinary(ByteBuffer.wrap(payload), true).join();
+        byte[] resp = reader.collect(ws);
+        ResponseWithPayload out = new ResponseWithPayload();
+        out.status = beInt(resp, 0);
+        if (out.status == STATUS_OK) {
+            int len = beInt(resp, 4);
+            out.payload = Arrays.copyOfRange(resp, 8, 8 + len);
+        }
+        return out;
+    }
+
+    static class WsBinaryCollector implements WebSocket.Listener {
+        private volatile CompletableFuture<byte[]> future = new CompletableFuture<>();
+        private ByteBuffer acc = ByteBuffer.allocate(0);
+
+        public synchronized byte[] collect(WebSocket ws) {
+            acc = ByteBuffer.allocate(0);
+            future = new CompletableFuture<>();
+            ws.request(1);
+            return future.join();
+        }
+
+        @Override public void onOpen(WebSocket ws) { ws.request(1); }
+        @Override public CompletionStage<?> onBinary(WebSocket ws, ByteBuffer data, boolean last) {
+            ByteBuffer newBuf = ByteBuffer.allocate(acc.remaining() + data.remaining());
+            newBuf.put(acc); newBuf.put(data); newBuf.flip();
+            acc = newBuf;
+            if (last) {
+                byte[] all = new byte[acc.remaining()];
+                acc.get(all);
+                future.complete(all);
+            }
+            ws.request(1);
+            return CompletableFuture.completedFuture(null);
+        }
+        @Override public CompletionStage<?> onText(WebSocket ws, CharSequence data, boolean last) {
+            if (last) future.complete(data.toString().getBytes(StandardCharsets.UTF_8));
+            ws.request(1);
+            return CompletableFuture.completedFuture(null);
+        }
+        @Override public void onError(WebSocket ws, Throwable error) { future.completeExceptionally(error); }
+    }
+
+    // ==============================================================
+    //                     Крипто и утилиты
+    // ==============================================================
+
+    static byte[] buildPreimage(String userLogin, long blockchainId, byte[] prevHash32, byte[] rawBytes) {
+        byte[] loginUtf8 = userLogin.getBytes(StandardCharsets.UTF_8);
+        ByteBuffer buf = ByteBuffer.allocate(loginUtf8.length + 8 + 32 + rawBytes.length).order(ByteOrder.BIG_ENDIAN);
+        buf.put(loginUtf8);
+        buf.putLong(blockchainId);
+        buf.put(prevHash32);
+        buf.put(rawBytes);
+        return buf.array();
+    }
+
+    static final class HashUtil {
+        static byte[] sha256(byte[] data) {
+            org.bouncycastle.crypto.digests.SHA256Digest d = new org.bouncycastle.crypto.digests.SHA256Digest();
+            d.update(data, 0, data.length);
+            byte[] out = new byte[32];
+            d.doFinal(out, 0);
+            return out;
+        }
+    }
+
+    static final class Ed25519Util {
+        static byte[] derivePublicKey(byte[] privateKey32) {
+            var priv = new org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters(privateKey32, 0);
+            return priv.generatePublicKey().getEncoded();
+        }
+        static byte[] sign(byte[] data, byte[] privateKey32) {
+            var priv = new org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters(privateKey32, 0);
+            var signer = new org.bouncycastle.crypto.signers.Ed25519Signer();
+            signer.init(true, priv);
+            signer.update(data, 0, data.length);
+            return signer.generateSignature();
+        }
+    }
+
+    // ==== Утилиты ====
+    static byte[] concat(byte[]... parts) {
+        int n = Arrays.stream(parts).mapToInt(a -> a.length).sum();
+        byte[] out = new byte[n];
+        int off = 0;
+        for (byte[] p : parts) { System.arraycopy(p, 0, out, off, p.length); off += p.length; }
+        return out;
+    }
+
+    static byte[] beInt(int v) { return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(v).array(); }
+    static byte[] beLong(long v) { return ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN).putLong(v).array(); }
+    static int beInt(byte[] a, int off) { return ByteBuffer.wrap(a, off, 4).order(ByteOrder.BIG_ENDIAN).getInt(); }
+
+    static String toHex(byte[] b) {
+        StringBuilder sb = new StringBuilder(b.length * 2);
+        for (byte x : b) sb.append(String.format("%02x", x));
+        return sb.toString();
+    }
+
+    static String statusName(int code) {
+        return switch (code) {
+            case STATUS_OK -> "OK";
+            case STATUS_BAD_REQUEST -> "BAD_REQUEST";
+            case STATUS_ALREADY_EXISTS -> "ALREADY_EXISTS";
+            case STATUS_NON_SEQUENTIAL -> "NON_SEQUENTIAL";
+            case STATUS_UNVERIFIED -> "UNVERIFIED";
+            case STATUS_INTERNAL -> "INTERNAL_ERROR";
+            default -> "UNKNOWN";
+        };
+    }
+}
+

src/main/java/server/logic/InboundMessageProcessor.java

@@ -0,0 +1,66 @@
+package server.logic;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.binary.handlers.*;
+import server.logic.ws_protocol.WireCodes;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Map;
+
+/**
+ * Обработчик входящих сообщение на сервер.
+ * По коду сообщения (первые 4 байта сообщения) находи нужный хэндлер и передаёт в него сообщение
+ * Получает и возвращает ответ от хэндлера
+ */
+public final class InboundMessageProcessor {
+    private static final Logger log = LoggerFactory.getLogger(InboundMessageProcessor.class);
+
+    private static final Map<Integer, MessageHandler> HANDLERS = Map.of(
+            WireCodes.Op.PING,          new PingHandler(),
+            WireCodes.Op.ADD_BLOCK,     new AddBlockHandler(),
+            WireCodes.Op.GET_BLOCKCHAIN,new GetBlockchainHandler(),
+            WireCodes.Op.SEARCH_USERS,  new SearchUsersHandler(),
+            WireCodes.Op.GET_LAST_BLOCK_INFO,new GetLastBlockInfoHandler()
+
+    );
+
+    private InboundMessageProcessor() {}
+
+    public static byte[] process(byte[] msg) {
+        if (msg == null || msg.length < 4)
+            return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
+
+        int op = first4ToInt(msg);
+        MessageHandler h = HANDLERS.get(op);
+        if (h == null) {
+            log.warn("Неизвестная операция: {}", op);
+            return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
+        }
+
+        try {
+            return h.handle(msg);
+        } catch (Exception e) {
+            log.error("Ошибка при обработке операции {}", op, e);
+            return intTo4Bytes(WireCodes.Status.INTERNAL_ERROR);
+        }
+    }
+
+    private static int first4ToInt(byte[] msg) {
+        return ByteBuffer.wrap(msg, 0, 4)
+                .order(ByteOrder.BIG_ENDIAN)
+                .getInt();
+    }
+
+    public static byte[] intTo4Bytes(int code) {
+        return ByteBuffer.allocate(4)
+                .order(ByteOrder.BIG_ENDIAN)
+                .putInt(code)
+                .array();
+    }
+
+
+
+}
+

src/main/java/server/logic/ws_protocol/binary/handlers/AddBlockHandler.java

@@ -0,0 +1,250 @@
+package server.logic.ws_protocol.binary.handlers;
+
+import blockchain.BchBlockEntry;
+import blockchain.body.BodyRecord;
+import blockchain.BodyRecordParser;
+import blockchain.body.HeaderBody;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.WireCodes;
+import utils.blockchain.BchInfoEntry;
+import utils.blockchain.BchInfoManager;
+import utils.crypto.BchCryptoVerifier;
+import utils.files.FileStoreUtil;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+/**
+ * AddBlockHandler — обработчик команды "добавить блок" (ADD_BLOCK)
+ * ---------------------------------------------------------------
+ * Принимает бинарное сообщение от клиента и добавляет новый блок в цепочку.
+ *
+ * Формат входного сообщения (msg):
+ *   [0..3]   — 4 байта: код операции (WireCodes.ADD_BLOCK)
+ *   [4..11]  — 8 байт: blockchainId (уникальный идентификатор цепочки)
+ *   [12..]   — байты полного блока .bch:
+ *                 ├── 4  байта  recordSize = M + 18
+ *                 ├── 4  байта  recordNumber
+ *                 ├── 8  байт   timestamp
+ *                 ├── 2  байта  recordType
+ *                 ├── 2  байта  recordVersion
+ *                 ├── M  байт   body (содержимое блока)
+ *                 ├── 64 байта  signature (Ed25519)
+ *                 └── 32 байта  hash (SHA-256)
+ *
+ * ---------------------------------------------------------------
+ * Алгоритм работы:
+ *
+ * 1️⃣ Распаковать BchBlockEntry из msg (т.е. выделить тело блока и подписи).
+ * 2️⃣ Найти описание цепочки (BchInfoEntry) по blockchainId.
+ *
+ *   ─ Если описания нет (цепочка ещё не существует):
+ *       • принимаем только блок типа 0 (HeaderBody) и номера 0;
+ *       • парсим его, создаём новый BchInfoEntry на основе данных заголовка;
+ *       • проверяем подпись и хэш;
+ *       • проверяем корректность тела блока (check);
+ *       • сохраняем блок и создаём новый blockchain-файл;
+ *       • добавляем цепочку в менеджер BchInfoManager.
+ *       (💡 временное решение: создание цепочки допустимо только через HeaderBody)
+ *
+ *   ─ Если цепочка уже существует:
+ *       • проверяем, что номер блока равен (lastBlockNumber + 1);
+ *       • проверяем подпись и хэш;
+ *       • проверяем тело блока (check);
+ *       • добавляем блок в файл цепочки;
+ *       • обновляем состояние BchInfoEntry (номер, хэш, размер).
+ *
+ * 3️⃣ Если все проверки пройдены — возвращаем статус OK.
+ *
+ * Таким образом, единственное различие между первым блоком и последующими —
+ * момент инициализации описания цепочки (BchInfoEntry).
+ * Всё остальное (валидация, подпись, добавление, обновление) выполняется одинаково.
+ */
+public class AddBlockHandler implements MessageHandler {
+
+    private static final Logger log = LoggerFactory.getLogger(AddBlockHandler.class);
+
+    @Override
+    public byte[] handle(byte[] msg) {
+        try {
+            // =====================================================================
+            // 1️⃣ Проверка минимальной длины пакета
+            // =====================================================================
+            int minFull = BchBlockEntry.RAW_HEADER_SIZE + BchBlockEntry.SIGNATURE_LEN + BchBlockEntry.HASH_LEN;
+            // (RAW_HEADER_SIZE = 18 байт, подпись = 64, хэш = 32)
+            if (msg.length < 4 + 8 + minFull)
+                return code(WireCodes.Status.BAD_REQUEST);
+
+            // =====================================================================
+            // 2️⃣ Извлекаем blockchainId (8 байт начиная с позиции 4)
+            // =====================================================================
+            long blockchainId = ByteBuffer.wrap(msg, 4, 8)
+                    .order(ByteOrder.BIG_ENDIAN)
+                    .getLong();
+
+            // Всё, что дальше, — это бинарное содержимое блока .bch
+            int offset = 12; // первые 12 байт = код + blockchainId
+
+            // =====================================================================
+            // 3️⃣ Парсим блок (RAW + подпись + хэш)
+            // =====================================================================
+            byte[] fullBlock = Arrays.copyOfRange(msg, offset, msg.length);
+            BchBlockEntry block = new BchBlockEntry(fullBlock); // сам распакует RAW-часть и подписи
+
+            // =====================================================================
+            // 4️⃣ Получаем текущее описание цепочки (BchInfoEntry)
+            // =====================================================================
+            BchInfoManager info = BchInfoManager.getInstance();
+            BchInfoEntry chain = info.getBchInfo(blockchainId);
+
+            byte[] prevHash32;
+            int expectedNum;
+            String userLogin;
+            byte[] publicKey32;
+
+            // =====================================================================
+            // 🧩 СЦЕНАРИЙ 1: цепочка отсутствует — создаём новую
+            // =====================================================================
+            if (chain == null) {
+                // Допускаем только блок-заголовок (type=0, num=0)
+                if (block.recordType != BchBlockEntry.TYPE_HEADER || block.recordNumber != 0) {
+                    log.warn("Попытка создать новую цепочку без корректного заголовка (type={}, num={})",
+                            block.recordType, block.recordNumber);
+                    return code(WireCodes.Status.BAD_REQUEST);
+                }
+
+                // Парсим тело блока → HeaderBody
+                BodyRecord body = BodyRecordParser.parse(block.recordType, block.recordTypeVersion, block.body).check();
+                if (!(body instanceof HeaderBody))
+                    return code(WireCodes.Status.BAD_REQUEST);
+
+                HeaderBody hb = (HeaderBody) body;
+
+                // Проверяем, что blockchainId совпадает
+                if (hb.blockchainId != blockchainId) {
+                    log.warn("Несовпадение blockchainId в заголовке (ожидалось {}, получено {})",
+                            blockchainId, hb.blockchainId);
+                    return code(WireCodes.Status.BAD_REQUEST);
+                }
+
+                // Проверяем подпись и хэш первого блока (предыдущий хэш = 0)
+                prevHash32 = new byte[32];
+                boolean verified = BchCryptoVerifier.verifyAll(
+                        hb.userLogin,
+                        blockchainId,
+                        prevHash32,
+                        block.rawBytes,
+                        block.getSignature64(),
+                        block.getHash32(),
+                        hb.publicKey32
+                );
+                if (!verified) {
+                    log.warn("❌ Подпись не прошла проверку при создании цепочки blockchainId={}", blockchainId);
+                    return code(WireCodes.Status.UNVERIFIED);
+                }
+
+                // ✅ Всё хорошо: создаём новую цепочку
+                info.addBlockchain(blockchainId, hb.userLogin, hb.publicKey32, Integer.MAX_VALUE);
+                info.updateBlockchainState(blockchainId, block.recordNumber, bytesToHex(block.getHash32()), fullBlock.length);
+
+                FileStoreUtil.getInstance().addDataToBlockchain(blockchainId, fullBlock);
+
+                log.info("✅ Создана новая цепочка blockchainId={}, user={}, blockNum={}",
+                        blockchainId, hb.userLogin, block.recordNumber);
+
+                return code(WireCodes.Status.OK);
+            }
+
+            // =====================================================================
+            // 🧩 СЦЕНАРИЙ 2: цепочка существует — добавляем новый блок
+            // =====================================================================
+            expectedNum = chain.lastBlockNumber + 1;
+
+            // Проверка последовательности (и отправка lastBlockNumber)
+            if (block.recordNumber < expectedNum) {
+                log.info("🔁 Блок {} уже существует, последний = {}", block.recordNumber, chain.lastBlockNumber);
+                ByteBuffer out = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN);
+                out.putInt(WireCodes.Status.BLOCK_ALREADY_EXISTS);
+                out.putInt(chain.lastBlockNumber);
+                return out.array();
+            }
+            if (block.recordNumber > expectedNum) {
+                log.warn("⚠️ Нарушена последовательность: получен {}, ожидался {}", block.recordNumber, expectedNum);
+                ByteBuffer out = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN);
+                out.putInt(WireCodes.Status.OUT_OF_SEQUENCE);
+                out.putInt(chain.lastBlockNumber);
+                return out.array();
+            }
+
+            userLogin = chain.userLogin;
+            publicKey32 = chain.getPublicKey32();
+
+            // Хэш предыдущего блока (или 32 нуля, если это первый)
+            prevHash32 = (chain.lastBlockHash == null || chain.lastBlockHash.isEmpty())
+                    ? new byte[32]
+                    : hexToBytes(chain.lastBlockHash);
+
+            // Проверяем подпись и хэш
+            boolean verified = BchCryptoVerifier.verifyAll(
+                    userLogin,
+                    blockchainId,
+                    prevHash32,
+                    block.rawBytes,
+                    block.getSignature64(),
+                    block.getHash32(),
+                    publicKey32
+            );
+            if (!verified) {
+                log.warn("❌ Подпись не прошла проверку: chainId={}, blockNum={}", blockchainId, block.recordNumber);
+                return code(WireCodes.Status.UNVERIFIED);
+            }
+
+            // Проверяем тело блока (например, корректный UTF-8 или структура)
+            BodyRecord body = BodyRecordParser.parse(block.recordType, block.recordTypeVersion, block.body).check();
+
+            // ✅ Добавляем блок в файл цепочки
+            FileStoreUtil.getInstance().addDataToBlockchain(blockchainId, fullBlock);
+
+            // Обновляем состояние цепочки (номер, хэш, размер)
+            int newSize = chain.blockchainSize + fullBlock.length;
+            info.updateBlockchainState(blockchainId, block.recordNumber, bytesToHex(block.getHash32()), newSize);
+
+            log.info("✅ Блок добавлен: chain={}, num={}, type={}, bytes={}",
+                    blockchainId, block.recordNumber, block.recordType, fullBlock.length);
+
+            return code(WireCodes.Status.OK);
+
+        } catch (Exception e) {
+            log.error("❌ ADD_BLOCK: внутренняя ошибка при обработке", e);
+            return code(WireCodes.Status.INTERNAL_ERROR);
+        }
+    }
+
+    // =====================================================================
+    //                            Утилиты
+    // =====================================================================
+
+    /** Преобразовать статус (int) в 4 байта BigEndian. */
+    private static byte[] code(int status) {
+        return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(status).array();
+    }
+
+    /** Конвертация HEX → bytes (для хэшей). */
+    private static byte[] hexToBytes(String hex) {
+        int len = hex.length();
+        byte[] out = new byte[len / 2];
+        for (int i = 0; i < len; i += 2)
+            out[i / 2] = (byte) Integer.parseInt(hex.substring(i, i + 2), 16);
+        return out;
+    }
+
+    /** Конвертация bytes → HEX (для сохранения в BchInfo). */
+    private static String bytesToHex(byte[] b) {
+        StringBuilder sb = new StringBuilder(b.length * 2);
+        for (byte x : b) sb.append(String.format("%02x", x));
+        return sb.toString();
+    }
+}
+

src/main/java/server/logic/ws_protocol/binary/handlers/GetBlockchainHandler.java

@@ -0,0 +1,53 @@
+package server.logic.ws_protocol.binary.handlers;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.WireCodes;
+import utils.files.FileStoreUtil;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Возврат полного содержимого блокчейна (GET_BLOCKCHAIN).
+ */
+public class GetBlockchainHandler implements MessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(GetBlockchainHandler.class);
+
+    @Override
+    public byte[] handle(byte[] msg) {
+        try {
+            if (msg.length < 12)
+                return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
+
+            long id = ByteBuffer.wrap(msg, 4, 8)
+                    .order(ByteOrder.BIG_ENDIAN)
+                    .getLong();
+
+            FileStoreUtil fs = FileStoreUtil.getInstance();
+            byte[] data = fs.readAllDataFromBlockchain(id);
+
+            return packOk(data);
+
+        } catch (IllegalStateException e) {
+            log.warn("GET_BLOCKCHAIN: файл не найден ({})", e.getMessage());
+            return intTo4Bytes(WireCodes.Status.CHAIN_NOT_FOUND);
+        } catch (Exception e) {
+            log.error("GET_BLOCKCHAIN: ошибка", e);
+            return intTo4Bytes(WireCodes.Status.INTERNAL_ERROR);
+        }
+    }
+
+    private static byte[] packOk(byte[] data) {
+        if (data == null) data = new byte[0];
+        ByteBuffer out = ByteBuffer.allocate(8 + data.length).order(ByteOrder.BIG_ENDIAN);
+        out.putInt(WireCodes.Status.OK);
+        out.putInt(data.length);
+        out.put(data);
+        return out.array();
+    }
+
+    private static byte[] intTo4Bytes(int code) {
+        return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(code).array();
+    }
+}

src/main/java/server/logic/ws_protocol/binary/handlers/GetLastBlockInfoHandler.java

@@ -0,0 +1,66 @@
+package server.logic.ws_protocol.binary.handlers;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.WireCodes;
+import utils.blockchain.BchInfoEntry;
+import utils.blockchain.BchInfoManager;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+/**
+ * Возврат информации о последнем блоке цепочки (GET_LAST_BLOCK_INFO).
+ */
+public class GetLastBlockInfoHandler implements MessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(GetLastBlockInfoHandler.class);
+
+    @Override
+    public byte[] handle(byte[] msg) {
+        try {
+            if (msg.length < 12)
+                return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
+
+            long blockchainId = ByteBuffer.wrap(msg, 4, 8)
+                    .order(ByteOrder.BIG_ENDIAN)
+                    .getLong();
+
+            BchInfoManager mgr = BchInfoManager.getInstance();
+            BchInfoEntry entry = mgr.getBchInfo(blockchainId);
+            if (entry == null)
+                return intTo4Bytes(WireCodes.Status.CHAIN_NOT_FOUND);
+
+            int lastNum = entry.lastBlockNumber;
+            byte[] hash = hexToBytes(entry.lastBlockHash);
+
+            ByteBuffer out = ByteBuffer.allocate(4 + 4 + 32).order(ByteOrder.BIG_ENDIAN);
+            out.putInt(WireCodes.Status.OK);
+            out.putInt(lastNum);
+            out.put(hash);
+            return out.array();
+
+        } catch (Exception e) {
+            log.error("GET_LAST_BLOCK_INFO: ошибка", e);
+            return intTo4Bytes(WireCodes.Status.INTERNAL_ERROR);
+        }
+    }
+
+    private static byte[] intTo4Bytes(int code) {
+        return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(code).array();
+    }
+
+    private static byte[] hexToBytes(String hex) {
+        if (hex == null || hex.isEmpty()) return new byte[32];
+        int len = hex.length();
+        byte[] out = new byte[len / 2];
+        for (int i = 0; i < len; i += 2)
+            out[i / 2] = (byte) Integer.parseInt(hex.substring(i, i + 2), 16);
+        if (out.length < 32) { // добиваем нулями
+            byte[] full = new byte[32];
+            System.arraycopy(out, 0, full, 32 - out.length, out.length);
+            return full;
+        }
+        return Arrays.copyOf(out, 32);
+    }
+}

src/main/java/server/logic/ws_protocol/binary/handlers/MessageHandler.java

@@ -0,0 +1,11 @@
+package server.logic.ws_protocol.binary.handlers;
+
+/**
+ * Общий интерфейс для всех обработчиков входящих сообщений.
+ */
+public interface MessageHandler {
+    /**
+     * Обработать входящее сообщение и вернуть бинарный ответ.
+     */
+    byte[] handle(byte[] msg);
+}

src/main/java/server/logic/ws_protocol/binary/handlers/PingHandler.java

@@ -0,0 +1,16 @@
+package server.logic.ws_protocol.binary.handlers;
+
+import server.logic.ws_protocol.WireCodes;
+
+/**
+ * Обработчик команды PING.
+ * Возвращает просто статус PONG.
+ */
+public class PingHandler implements MessageHandler {
+    @Override
+    public byte[] handle(byte[] msg) {
+        return new byte[]{
+                0, 0, 0, (byte) WireCodes.Status.PONG  // проще и быстрее, можно и через ByteBuffer
+        };
+    }
+}

src/main/java/server/logic/ws_protocol/binary/handlers/SearchUsersHandler.java

@@ -0,0 +1,59 @@
+package server.logic.ws_protocol.binary.handlers;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.WireCodes;
+import utils.search.UserSearchService;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+/**
+ * Поиск пользователей по логину (SEARCH_USERS).
+ */
+public class SearchUsersHandler implements MessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(SearchUsersHandler.class);
+
+    @Override
+    public byte[] handle(byte[] msg) {
+        try {
+            if (msg.length < 8)
+                return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
+
+            int N = ByteBuffer.wrap(msg, 4, 4).order(ByteOrder.BIG_ENDIAN).getInt();
+            if (N < 0 || msg.length < 8 + N)
+                return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
+
+            String query = new String(msg, 8, N, StandardCharsets.UTF_8);
+            List<UserSearchService.Pair> found = UserSearchService.getInstance().searchFirst5(query);
+            return pack(found);
+
+        } catch (Exception e) {
+            log.error("SEARCH_USERS: ошибка", e);
+            return intTo4Bytes(WireCodes.Status.INTERNAL_ERROR);
+        }
+    }
+
+    private static byte[] pack(List<UserSearchService.Pair> pairs) {
+        if (pairs == null) pairs = List.of();
+        int total = 8;
+        var chunks = new java.util.ArrayList<byte[]>();
+        for (var p : pairs) {
+            byte[] packed = UserSearchService.packPair(p);
+            chunks.add(packed);
+            total += packed.length;
+        }
+
+        ByteBuffer out = ByteBuffer.allocate(total).order(ByteOrder.BIG_ENDIAN);
+        out.putInt(WireCodes.Status.OK);
+        out.putInt(pairs.size());
+        for (var c : chunks) out.put(c);
+        return out.array();
+    }
+
+    private static byte[] intTo4Bytes(int code) {
+        return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(code).array();
+    }
+}

src/main/java/server/ws/BlockchainWsEndpoint.java

@@ -0,0 +1,141 @@
+package server.ws;
+
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.api.WriteCallback;
+import org.eclipse.jetty.websocket.api.annotations.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.InboundMessageProcessor;
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.JsonInboundProcessor;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.CompletableFuture;
+
+@WebSocket
+public class BlockchainWsEndpoint {
+    private static final Logger log = LoggerFactory.getLogger(BlockchainWsEndpoint.class);
+
+    private Session session;
+
+    /** Контекст для текущего WebSocket-соединения. */
+    private final ConnectionContext connectionContext = new ConnectionContext();
+
+    @OnWebSocketConnect
+    public void onConnect(Session session) {
+        this.session = session;
+        log.info("WS connected: {}", session.getRemoteAddress());
+    }
+
+    @OnWebSocketMessage
+    public void onBinary(byte[] payload, int offset, int length) {
+        byte[] msg = new byte[length];
+        System.arraycopy(payload, offset, msg, 0, length);
+
+        // Асинхронно обрабатываем входящее бинарное сообщение
+        CompletableFuture
+                .supplyAsync(() -> InboundMessageProcessor.process(msg))
+                .thenAccept(resp -> {
+                    if (resp != null && session != null && session.isOpen()) {
+                        session.getRemote().sendBytes(ByteBuffer.wrap(resp), new WriteCallback() {
+                            @Override
+                            public void writeFailed(Throwable x) {
+                                log.warn("Failed to send response", x);
+                            }
+
+                            @Override
+                            public void writeSuccess() {
+                                log.debug("Response sent successfully");
+                            }
+                        });
+                    }
+                })
+                .exceptionally(ex -> {
+                    log.error("Processing failed", ex);
+                    trySendCode(500);
+                    return null;
+                });
+    }
+
+    private void trySendCode(int code) {
+        if (session != null && session.isOpen()) {
+            byte[] resp = InboundMessageProcessor.intTo4Bytes(code);
+            session.getRemote().sendBytes(ByteBuffer.wrap(resp), new WriteCallback() {
+                @Override
+                public void writeFailed(Throwable x) {
+                    log.warn("Failed to send error code", x);
+                }
+
+                @Override
+                public void writeSuccess() {
+                    log.debug("Error code {} sent", code);
+                }
+            });
+        }
+    }
+
+    @OnWebSocketClose
+    public void onClose(int statusCode, String reason) {
+        log.info("WS closed: {} {}", statusCode, reason);
+        // На всякий случай очищаем контекст
+        connectionContext.reset();
+    }
+
+    @OnWebSocketError
+    public void onError(Throwable cause) {
+        log.error("WS error", cause);
+    }
+
+    // Обработка текстовых JSON-запросов
+    @OnWebSocketMessage
+    public void onText(String message) {
+        log.info("📥 Получено TEXT-сообщение от клиента: {}", message);
+
+        CompletableFuture
+                .supplyAsync(() -> JsonInboundProcessor.processJson(message, connectionContext))
+                .thenAccept(respJson -> {
+                    if (respJson != null && session != null && session.isOpen()) {
+
+                        log.info("📤 Отправляем ответ клиенту: {}", respJson);
+
+                        session.getRemote().sendString(respJson, new WriteCallback() {
+                            @Override
+                            public void writeFailed(Throwable x) {
+                                log.warn("⚠️ Не удалось отправить JSON-ответ клиенту: {}", x.toString());
+                            }
+
+                            @Override
+                            public void writeSuccess() {
+                                log.debug("✔ JSON-ответ успешно отправлен");
+                            }
+                        });
+                    }
+                })
+                .exceptionally(ex -> {
+                    log.error("❌ Ошибка при обработке JSON-сообщения", ex);
+                    trySendJsonError();
+                    return null;
+                });
+    }
+
+    private void trySendJsonError() {
+        if (session != null && session.isOpen()) {
+            String resp = "{\"op\":null,\"requestId\":null,\"status\":500,"
+                    + "\"payload\":{\"code\":\"INTERNAL_ERROR\",\"message\":\"Ошибка сервера\"}}";
+
+            log.info("📤 Отправляем клиенту ошибку JSON: {}", resp);
+
+            session.getRemote().sendString(resp, new WriteCallback() {
+                @Override
+                public void writeFailed(Throwable x) {
+                    log.warn("⚠️ Не удалось отправить JSON-ответ клиенту: {}", x.toString());
+                }
+
+                @Override
+                public void writeSuccess() {
+                    log.debug("✔ JSON-ошибка успешно отправлена");
+                }
+            });
+        }
+    }
+}

src/main/java/server/ws/README.md

@@ -0,0 +1,85 @@
+# server.ws
+
+Пакет `server.ws` отвечает за сетевой уровень: WebSocket-сервер и обработку соединений.
+
+Он принимает бинарные сообщения от клиентов, передаёт их в логику сервера и отправляет бинарные ответы обратно.
+
+---
+
+## Классы
+
+### 1. `BlockchainWsEndpoint`
+WebSocket-эндпоинт для одного соединения.
+
+Роль:
+- держит сессию с конкретным клиентом,
+- принимает сообщения,
+- вызывает бизнес-логику,
+- отправляет ответ.
+
+Публичные методы (Jetty WebSocket lifecycle):
+
+- `onConnect(Session session)`  
+  Вызывается Jetty при подключении клиента.  
+  Сохраняет `session`, пишет лог.
+
+- `onBinary(byte[] payload, int offset, int length)`  
+  Клиент прислал бинарные данные.  
+  Логика:
+    1. Копируем полезные байты.
+    2. Передаём их в `InboundMessageProcessor.process(...)`.
+    3. Асинхронно отправляем ответ обратно через `session.getRemote().sendBytes(...)`.
+
+  Ответ сервера — это либо `[4]statusCode`, либо `[4]OK + ...payload...` (в зависимости от операции).
+
+- `onClose(int statusCode, String reason)`  
+  Логируем закрытие сессии.
+
+- `onError(Throwable cause)`  
+  Логируем ошибку.
+
+Внутренние (служебные):
+- `trySendCode(int code)` — отправить просто код ошибки, если что-то пошло не так.
+
+Замечание: сам `BlockchainWsEndpoint` не знает протокола. Он просто прокидывает байты в `InboundMessageProcessor`.
+
+---
+
+### 2. `WsServer`
+Отдельный класс-ланчер. Поднимает Jetty WebSocket сервер.
+
+Роль:
+- стартует HTTP-сервер Jetty на порту `8080`,
+- вешает WebSocket endpoint `/ws`,
+- задаёт таймаут бездействия.
+
+Публичный метод:
+- `public static void main(String[] args)`  
+  Запуск сервера. Делает:
+    - `new Server(8080)`
+    - создаёт `ServletContextHandler`
+    - через `JettyWebSocketServletContainerInitializer.configure(...)` регистрирует маппинг `/ws` → `BlockchainWsEndpoint`
+    - `server.start(); server.join();`
+
+После запуска сервер слушает `ws://localhost:8080/ws`.
+
+---
+
+## Как это стыкуется с остальной системой
+
+1. Клиент открывает WebSocket на `/ws`.
+2. Шлёт бинарный пакет: `[4 байта opCode][дальше payload]`.
+3. `BlockchainWsEndpoint.onBinary()` → `InboundMessageProcessor.process(...)`.
+4. `InboundMessageProcessor` разбирает команду:
+    - добавить блок
+    - выдать блокчейн
+    - поиск пользователей
+    - ping
+5. Ответ упаковывается в бинарный формат и отправляется обратно через `BlockchainWsEndpoint`.
+
+---
+
+## Кратко
+
+- `WsServer` = сервер, который слушает порт и вешает `/ws`.
+- `BlockchainWsEndpoint` = обработчик одного WebSocket-подключения, мост между сетью и логикой.

src/main/java/server/ws/WsServer.java

@@ -0,0 +1,48 @@
+package server.ws;
+
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerInitializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import shine.db.dao.SolanaUsersDAO;
+import shine.db.entities.SolanaUser;
+import utils.config.AppConfig;
+
+import java.time.Duration;
+
+/**
+ * WsServer — поднимает Jetty WS на /ws (порт 8080).
+ */
+public final class WsServer {
+    private static final Logger log = LoggerFactory.getLogger(WsServer.class);
+
+    public static void main(String[] args) throws Exception {
+        AppConfig config = AppConfig.getInstance();
+        int port = 7070;
+        try {
+            port = Integer.parseInt(config.getParam("server.port"),7070);
+        } catch (Exception e) {
+            log.info("Установите параметр server.port в файле настроек");
+        }
+
+        Server server = new Server(port);
+
+        ServletContextHandler context = new ServletContextHandler();
+        context.setContextPath("/");
+        server.setHandler(context);
+
+        // Инициализация контейнера WebSocket
+        JettyWebSocketServletContainerInitializer.configure(context, (servletContext, wsContainer) -> {
+            // Таймаут простоя соединения (Jetty 11 синтаксис)
+            wsContainer.setIdleTimeout(Duration.ofMinutes(5));
+
+            // Маппинг эндпоинта
+            wsContainer.addMapping("/ws", (req, resp) -> new BlockchainWsEndpoint());
+        });
+
+        server.start();
+        log.info("✅ WS сервер запущен на ws://localhost:{}/ws", port);
+        server.join();
+    }
+}

src/main/resources/application.properties

@@ -0,0 +1,5 @@
+server.1port=7070
+
+
+db.path=data/shine.sqlite
+

src/main/resources/logback.xml

@@ -0,0 +1,33 @@
+<configuration>
+
+    <!-- ========== Настройки формата лога ========== -->
+    <property name="LOG_DIR" value="logs" />
+    <property name="LOG_FILE" value="${LOG_DIR}/app.log" />
+
+    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${LOG_FILE}</file>
+
+        <!-- Ротация файлов: по дате -->
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${LOG_DIR}/app.%d{yyyy-MM-dd}.log</fileNamePattern>
+            <maxHistory>14</maxHistory>
+        </rollingPolicy>
+
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%highlight(%-5level) %cyan(%logger{20}) - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <!-- ========== Уровень логирования ========== -->
+    <root level="info">
+        <appender-ref ref="CONSOLE" />
+        <appender-ref ref="FILE" />
+    </root>
+
+</configuration>

src/test_ws.html

@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <title>Blockchain WS Test</title>
+    <style>
+        body { font-family: monospace; background: #0d1117; color: #c9d1d9; padding: 20px; }
+        h1 { color: #58a6ff; }
+        #log { white-space: pre-wrap; border: 1px solid #30363d; padding: 10px; background: #161b22; height: 500px; overflow-y: auto; }
+        button { background: #238636; color: white; border: none; padding: 10px 16px; border-radius: 6px; cursor: pointer; margin-right: 10px; }
+        button:hover { background: #2ea043; }
+        input { background: #0d1117; color: white; border: 1px solid #30363d; padding: 8px; border-radius: 6px; width: 300px; }
+    </style>
+</head>
+<body>
+
+<h1>🔗 WebSocket Blockchain Test</h1>
+<p>URL: <b>wss://shineup.me/ws</b></p>
+<button id="btnConnect">Connect</button>
+<button id="btnAddHeader">Add Header</button>
+<button id="btnGetChain">Get Chain</button>
+<br><br>
+<label for="textInput"></label><input id="textInput" placeholder="Введите текст для нового блока">
+<button id="btnAddText">Add Text</button>
+<br><br>
+<div id="log"></div>
+
+<script>
+    const log = msg => {
+        const el = document.getElementById("log");
+        el.textContent += msg + "\n";
+        el.scrollTop = el.scrollHeight;
+    };
+
+    // === Константы ===
+    const WS_URL = "wss://shineup.me/ws";
+    const OP_ADD_BLOCK = 1;
+    const OP_GET_BLOCKCHAIN = 2;
+    const TYPE_HEADER = 0;
+    const TYPE_TEXT = 1;
+
+    let ws;
+    let blockchainId = 777000001n;
+    let userLogin = "test_user_js";
+
+    function beInt(v) {
+        const buf = new ArrayBuffer(4);
+        new DataView(buf).setInt32(0, v, false);
+        return new Uint8Array(buf);
+    }
+    function beLong(v) {
+        const buf = new ArrayBuffer(8);
+        new DataView(buf).setBigInt64(0, BigInt(v), false);
+        return new Uint8Array(buf);
+    }
+    function concat(...arrs) {
+        let len = arrs.reduce((a, b) => a + b.length, 0);
+        let out = new Uint8Array(len);
+        let off = 0;
+        for (let a of arrs) { out.set(a, off); off += a.length; }
+        return out;
+    }
+    function textUtf8(s) {
+        return new TextEncoder().encode(s);
+    }
+
+    // === Построение HEADER ===
+    function buildHeaderBody() {
+        const tag = textUtf8("SHiNE001");
+        const id = beLong(blockchainId);
+        const login = textUtf8(userLogin);
+        const loginLen = new Uint8Array([login.length]);
+        const zeros = new Uint8Array(4+4+2+8+32); // type, num, ver, prev, pubkey
+        return concat(tag, id, loginLen, login, zeros);
+    }
+
+    function buildRawRecord(recordNumber, timestamp, recordType, recordTypeVersion, body) {
+        const recordSize = 4+4+8+2+2+body.length;
+        const buf = new ArrayBuffer(20);
+        const view = new DataView(buf);
+        view.setInt32(0, recordSize, false);
+        view.setInt32(4, recordNumber, false);
+        view.setBigInt64(8, BigInt(timestamp), false);
+        view.setInt16(16, recordType, false);
+        view.setInt16(18, recordTypeVersion, false);
+        return concat(new Uint8Array(buf), body);
+    }
+
+    // === Команды ===
+    document.getElementById("btnConnect").onclick = () => {
+        ws = new WebSocket(WS_URL);
+        ws.binaryType = "arraybuffer";
+
+        ws.onopen = () => log("✅ Connected to " + WS_URL);
+        ws.onclose = () => log("❌ Disconnected");
+        ws.onerror = e => log("⚠️ Error: " + e.message);
+
+        ws.onmessage = e => {
+            const data = new Uint8Array(e.data);
+            const status = new DataView(data.buffer).getInt32(0, false);
+            log("📩 Received status: " + status);
+            if (data.length > 8) {
+                const len = new DataView(data.buffer).getInt32(4, false);
+                const payload = data.slice(8, 8 + len);
+                log("Payload (" + len + " bytes): " + toHex(payload.slice(0, 64)) + "...");
+            }
+        };
+    };
+
+    document.getElementById("btnAddHeader").onclick = () => {
+        if (!ws || ws.readyState !== WebSocket.OPEN) return log("⚠️ Not connected");
+        const body = buildHeaderBody();
+        const ts = Math.floor(Date.now() / 1000);
+        const raw = buildRawRecord(0, ts, TYPE_HEADER, 1, body);
+        const msg = concat(beInt(OP_ADD_BLOCK), beLong(blockchainId), raw);
+        ws.send(msg);
+        log("📤 Sent ADD_HEADER (" + raw.length + " bytes)");
+    };
+
+    document.getElementById("btnGetChain").onclick = () => {
+        if (!ws || ws.readyState !== WebSocket.OPEN) return log("⚠️ Not connected");
+        const msg = concat(beInt(OP_GET_BLOCKCHAIN), beLong(blockchainId));
+        ws.send(msg);
+        log("📤 Sent GET_BLOCKCHAIN");
+    };
+
+    document.getElementById("btnAddText").onclick = () => {
+        if (!ws || ws.readyState !== WebSocket.OPEN) return log("⚠️ Not connected");
+        const txt = document.getElementById("textInput").value.trim();
+        if (!txt) return log("⚠️ Пустое сообщение");
+        const body = textUtf8(txt);
+        const ts = Math.floor(Date.now() / 1000);
+        const raw = buildRawRecord(1, ts, TYPE_TEXT, 1, body);
+        const msg = concat(beInt(OP_ADD_BLOCK), beLong(blockchainId), raw);
+        ws.send(msg);
+        log("📤 Sent ADD_TEXT (" + txt + ")");
+    };
+
+    // === Helpers ===
+    function toHex(buf) {
+        return Array.from(buf).map(b => b.toString(16).padStart(2, "0")).join("");
+    }
+</script>
+</body>
+</html>