Добавить поддержку уведомлений

SHiNE-server/shine-server-blockchain/src/main/java/blockchain/MsgSubType.java

@@ -98,14 +98,9 @@ public final class MsgSubType {
     /* ===================== CONNECTION (msg_type=3) ===================== */
 
     /** Добавить в близкие друзья (close friend). */
-    public static final short CONNECTION_FRIEND = 10;
+    public static final short CONNECTION_CLOSE_FRIEND = 10;
     /** Удалить из близких друзей (close friend). */
-    public static final short CONNECTION_UNFRIEND = 11;
-
-    /** Alias: добавить в close friend (то же значение, что CONNECTION_FRIEND). */
-    public static final short CONNECTION_CLOSE_FRIEND = CONNECTION_FRIEND;
-    /** Alias: удалить из close friend (то же значение, что CONNECTION_UNFRIEND). */
-    public static final short CONNECTION_UNCLOSE_FRIEND = CONNECTION_UNFRIEND;
+    public static final short CONNECTION_UNCLOSE_FRIEND = 11;
 
     /** Добавить в контакты. */
     public static final short CONNECTION_CONTACT = 20;

SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ConnectionBody.java

@@ -66,7 +66,7 @@ import java.util.Objects;
  *                     toBlockHash32=hash32(CREATE_CHANNEL)
  *
  *  3) ЗАПРЕТЫ ВАЛИДАЦИИ (желательно на сервере/в БД):
- *     - CONNECTION_FRIEND/CONTACT не могут ссылаться на не-HEADER (toBlockNumber != 0 запрещено).
+ *     - CONNECTION_CLOSE_FRIEND/CONTACT не могут ссылаться на не-HEADER (toBlockNumber != 0 запрещено).
  *     - FOLLOW на канал "X" не может ссылаться на произвольный пост внутри канала:
  *       разрешено ТОЛЬКО на ROOT (HEADER или CREATE_CHANNEL).
  *
@@ -183,8 +183,8 @@ public final class ConnectionBody implements BodyRecord, BodyHasTarget, BodyHasL
 
     private static boolean isValidSubType(short st) {
         int v = st & 0xFFFF;
-        return v == (MsgSubType.CONNECTION_FRIEND & 0xFFFF)
-                || v == (MsgSubType.CONNECTION_UNFRIEND & 0xFFFF)
+        return v == (MsgSubType.CONNECTION_CLOSE_FRIEND & 0xFFFF)
+                || v == (MsgSubType.CONNECTION_UNCLOSE_FRIEND & 0xFFFF)
                 || v == (MsgSubType.CONNECTION_CONTACT & 0xFFFF)
                 || v == (MsgSubType.CONNECTION_UNCONTACT & 0xFFFF)
                 || v == (MsgSubType.CONNECTION_FOLLOW & 0xFFFF)

SHiNE-server/shine-server-config/src/main/java/utils/config/ShineSignatureConstants.java

@@ -14,6 +14,9 @@ public final class ShineSignatureConstants {
     /** Подписываемые данные параметра пользователя: prefix + login + param + time_ms + value */
     public static final String USER_PARAMETER_PREFIX = "SHiNe/UserParameter:";
 
+    /** Подписываемые данные пользовательских настроек: prefix + login + type + key + time_ms + value_text + value_num */
+    public static final String USER_SETTINGS_PREFIX = "SHiNe/UserSettings:";
+
     /** TAG в HeaderBody (genesis). ASCII "SHiNe". */
     public static final String BLOCKCHAIN_HEADER_TAG = "SHiNe";
 

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

@@ -25,6 +25,8 @@ public final class DatabaseInitializer {
     public static final int SCHEMA_VERSION_6 = 6;
     public static final int SCHEMA_VERSION_7 = 7;
     public static final int SCHEMA_VERSION_8 = 8;
+    public static final int SCHEMA_VERSION_9 = 9;
+    public static final int SCHEMA_VERSION_10 = 10;
     public static final String POSTGRES_SCHEMA_RESOURCE = "postgres/schema_v1.sql";
     public static final String POSTGRES_MIGRATION_V2_RESOURCE = "postgres/migration_v2.sql";
     public static final String POSTGRES_MIGRATION_V3_RESOURCE = "postgres/migration_v3.sql";
@@ -33,6 +35,8 @@ public final class DatabaseInitializer {
     public static final String POSTGRES_MIGRATION_V6_RESOURCE = "postgres/migration_v6.sql";
     public static final String POSTGRES_MIGRATION_V7_RESOURCE = "postgres/migration_v7.sql";
     public static final String POSTGRES_MIGRATION_V8_RESOURCE = "postgres/migration_v8.sql";
+    public static final String POSTGRES_MIGRATION_V9_RESOURCE = "postgres/migration_v9.sql";
+    public static final String POSTGRES_MIGRATION_V10_RESOURCE = "postgres/migration_v10.sql";
 
     private DatabaseInitializer() {}
 
@@ -51,10 +55,8 @@ public final class DatabaseInitializer {
     public static final short REACTION_LIKE = 1;
     public static final short REACTION_UNLIKE = 2;
 
-    public static final short CONNECTION_FRIEND     = 10;
-    public static final short CONNECTION_UNFRIEND   = 11;
-    public static final short CONNECTION_CLOSE_FRIEND   = CONNECTION_FRIEND;
-    public static final short CONNECTION_UNCLOSE_FRIEND = CONNECTION_UNFRIEND;
+    public static final short CONNECTION_CLOSE_FRIEND   = 10;
+    public static final short CONNECTION_UNCLOSE_FRIEND = 11;
 
     public static final short CONNECTION_CONTACT    = 20;
     public static final short CONNECTION_UNCONTACT  = 21;
@@ -124,6 +126,14 @@ public final class DatabaseInitializer {
             }
             if (currentVersion < SCHEMA_VERSION_8) {
                 runSqlScript(conn, POSTGRES_MIGRATION_V8_RESOURCE);
+                currentVersion = SCHEMA_VERSION_8;
+            }
+            if (currentVersion < SCHEMA_VERSION_9) {
+                runSqlScript(conn, POSTGRES_MIGRATION_V9_RESOURCE);
+                currentVersion = SCHEMA_VERSION_9;
+            }
+            if (currentVersion < SCHEMA_VERSION_10) {
+                runSqlScript(conn, POSTGRES_MIGRATION_V10_RESOURCE);
             }
         }
     }

SHiNE-server/shine-server-db/src/main/java/shine/db/MsgSubType.java

@@ -58,23 +58,17 @@ public final class MsgSubType {
     /* ===================== CONNECTION (msg_type=3) ===================== */
     /**
  * Совпадает с ConnectionBody:
- * SET:   CLOSE_FRIEND(=FRIEND)=10, CONTACT=20, FOLLOW=30, SPOUSE=40, PARENT=50, CHILD=52, SIBLING=54,
+ * SET:   CLOSE_FRIEND=10, CONTACT=20, FOLLOW=30, SPOUSE=40, PARENT=50, CHILD=52, SIBLING=54,
  *        KNOWN_PERSON=60, SHINE_CONFIRMED=70, SHINE_SEEN=74
- * UNSET: UNCLOSE_FRIEND(=UNFRIEND)=11, UNCONTACT=21, UNFOLLOW=31, UNSPOUSE=41, UNPARENT=51, UNCHILD=53, UNSIBLING=55,
+ * UNSET: UNCLOSE_FRIEND=11, UNCONTACT=21, UNFOLLOW=31, UNSPOUSE=41, UNPARENT=51, UNCHILD=53, UNSIBLING=55,
  *        UNKNOWN_PERSON=61, SHINE_UNCONFIRMED=71, SHINE_UNSEEN=75
      */
 
     /** Добавить в близкие друзья (close friend). */
-    public static final short CONNECTION_FRIEND = 10;
+    public static final short CONNECTION_CLOSE_FRIEND = 10;
 
     /** Удалить из близких друзей (close friend). */
-    public static final short CONNECTION_UNFRIEND = 11;
-
-    /** Alias: добавить в close friend (то же значение, что CONNECTION_FRIEND). */
-    public static final short CONNECTION_CLOSE_FRIEND = CONNECTION_FRIEND;
-
-    /** Alias: удалить из close friend (то же значение, что CONNECTION_UNFRIEND). */
-    public static final short CONNECTION_UNCLOSE_FRIEND = CONNECTION_UNFRIEND;
+    public static final short CONNECTION_UNCLOSE_FRIEND = 11;
 
     /** Добавить в контакты. */
     public static final short CONNECTION_CONTACT = 20;

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainResyncCleanupDAO.java

@@ -185,10 +185,10 @@ public final class BlockchainResyncCleanupDAO {
     private int decreaseForeignLikesCount(Connection c, String blockchainName) throws SQLException {
         String sql = """
             UPDATE message_stats
-            SET likes_count = MAX(
+            SET likes_count = GREATEST(
                 0,
-                likes_count - (
-                    SELECT COUNT(*)
+                likes_count - COALESCE((
+                    SELECT COUNT(*)::int
                     FROM reactions_state rs
                     WHERE rs.from_bch_name = ?
                       AND rs.reaction_type = ?
@@ -198,7 +198,7 @@ public final class BlockchainResyncCleanupDAO {
                       AND rs.to_block_number = message_stats.to_block_number
                       AND rs.to_block_hash = message_stats.to_block_hash
                       AND rs.to_bch_name <> ?
-                )
+                ), 0)
             )
             WHERE EXISTS (
                 SELECT 1
@@ -237,10 +237,10 @@ public final class BlockchainResyncCleanupDAO {
     private int decreaseForeignRepliesCount(Connection c, String blockchainName) throws SQLException {
         String sql = """
             UPDATE message_stats
-            SET replies_count = MAX(
+            SET replies_count = GREATEST(
                 0,
                 replies_count - COALESCE((
-                    SELECT COUNT(*)
+                    SELECT COUNT(*)::int
                     FROM blocks b
                     WHERE b.bch_name = ?
                       AND b.msg_type = 1

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/DirectMessagesDAO.java

@@ -1,53 +0,0 @@
-package shine.db.dao;
-
-import shine.db.DbController;
-import shine.db.entities.DirectMessageEntry;
-
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-
-public final class DirectMessagesDAO {
-    private static volatile DirectMessagesDAO instance;
-    private final DbController db = DbController.getInstance();
-
-    private DirectMessagesDAO() {}
-
-    public static DirectMessagesDAO getInstance() {
-        if (instance == null) {
-            synchronized (DirectMessagesDAO.class) {
-                if (instance == null) instance = new DirectMessagesDAO();
-            }
-        }
-        return instance;
-    }
-
-    public void insert(DirectMessageEntry entry) throws Exception {
-        try (Connection c = db.getConnection()) {
-            String sql = """
-                INSERT INTO direct_messages (
-                    message_id, from_login, to_login, text, created_at_ms
-                ) VALUES (?, ?, ?, ?, ?)
-                """;
-            try (PreparedStatement ps = c.prepareStatement(sql)) {
-                ps.setString(1, entry.getMessageId());
-                ps.setString(2, entry.getFromLogin());
-                ps.setString(3, entry.getToLogin());
-                ps.setString(4, entry.getText());
-                ps.setLong(5, entry.getCreatedAtMs());
-                ps.executeUpdate();
-            }
-        }
-    }
-
-    public boolean existsFromTo(String fromLogin, String toLogin) throws Exception {
-        try (Connection c = db.getConnection()) {
-            String sql = "SELECT 1 FROM direct_messages WHERE from_login = ? AND to_login = ? LIMIT 1";
-            try (PreparedStatement ps = c.prepareStatement(sql)) {
-                ps.setString(1, fromLogin);
-                ps.setString(2, toLogin);
-                return ps.executeQuery().next();
-            }
-        }
-    }
-
-}

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SignedDirectMessagesHistoryDAO.java

@@ -1,47 +0,0 @@
-package shine.db.dao;
-
-import shine.db.DbController;
-import shine.db.entities.SignedDirectMessageHistoryEntry;
-
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-
-public final class SignedDirectMessagesHistoryDAO {
-    private static volatile SignedDirectMessagesHistoryDAO instance;
-    private final DbController db = DbController.getInstance();
-
-    private SignedDirectMessagesHistoryDAO() {}
-
-    public static SignedDirectMessagesHistoryDAO getInstance() {
-        if (instance == null) {
-            synchronized (SignedDirectMessagesHistoryDAO.class) {
-                if (instance == null) instance = new SignedDirectMessagesHistoryDAO();
-            }
-        }
-        return instance;
-    }
-
-    public void insert(SignedDirectMessageHistoryEntry e) throws Exception {
-        try (Connection c = db.getConnection()) {
-            String sql = """
-                INSERT INTO signed_direct_messages_history (
-                    message_id, from_login, to_login, target_mode, target_session_id,
-                    message_type, time_ms, nonce, raw_packet, created_at_ms
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """;
-            try (PreparedStatement ps = c.prepareStatement(sql)) {
-                ps.setString(1, e.getMessageId());
-                ps.setString(2, e.getFromLogin());
-                ps.setString(3, e.getToLogin());
-                ps.setInt(4, e.getTargetMode());
-                ps.setString(5, e.getTargetSessionId());
-                ps.setInt(6, e.getMessageType());
-                ps.setLong(7, e.getTimeMs());
-                ps.setLong(8, e.getNonce());
-                ps.setBytes(9, e.getRawPacket());
-                ps.setLong(10, e.getCreatedAtMs());
-                ps.executeUpdate();
-            }
-        }
-    }
-}

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SignedDmReplayDAO.java

@@ -1,51 +0,0 @@
-package shine.db.dao;
-
-import shine.db.DbController;
-
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-
-public final class SignedDmReplayDAO {
-    private static volatile SignedDmReplayDAO instance;
-    private final DbController db = DbController.getInstance();
-
-    private SignedDmReplayDAO() {}
-
-    public static SignedDmReplayDAO getInstance() {
-        if (instance == null) {
-            synchronized (SignedDmReplayDAO.class) {
-                if (instance == null) instance = new SignedDmReplayDAO();
-            }
-        }
-        return instance;
-    }
-
-    public boolean registerUnique(String fromLogin, long timeMs, long nonce, long nowMs) throws Exception {
-        cleanupExpired(nowMs - 15L * 60L * 1000L);
-        try (Connection c = db.getConnection()) {
-            String sql = """
-                    INSERT INTO signed_direct_message_replay (
-                        from_login, time_ms, nonce, created_at_ms
-                    ) VALUES (?, ?, ?, ?)
-                    ON CONFLICT DO NOTHING
-                    """;
-            try (PreparedStatement ps = c.prepareStatement(sql)) {
-                ps.setString(1, fromLogin);
-                ps.setLong(2, timeMs);
-                ps.setLong(3, nonce);
-                ps.setLong(4, nowMs);
-                return ps.executeUpdate() > 0;
-            }
-        }
-    }
-
-    public void cleanupExpired(long minCreatedAtMs) throws Exception {
-        try (Connection c = db.getConnection()) {
-            String sql = "DELETE FROM signed_direct_message_replay WHERE created_at_ms < ?";
-            try (PreparedStatement ps = c.prepareStatement(sql)) {
-                ps.setLong(1, minCreatedAtMs);
-                ps.executeUpdate();
-            }
-        }
-    }
-}

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserNotificationsStateDAO.java

@@ -0,0 +1,105 @@
+package shine.db.dao;
+
+import shine.db.DbController;
+import shine.db.entities.UserNotificationEntry;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class UserNotificationsStateDAO {
+    private static volatile UserNotificationsStateDAO instance;
+    private final DbController db = DbController.getInstance();
+
+    private UserNotificationsStateDAO() {}
+
+    public static UserNotificationsStateDAO getInstance() {
+        if (instance == null) {
+            synchronized (UserNotificationsStateDAO.class) {
+                if (instance == null) instance = new UserNotificationsStateDAO();
+            }
+        }
+        return instance;
+    }
+
+    public int upsert(Connection c, UserNotificationEntry e) throws SQLException {
+        String sql = """
+            INSERT INTO user_notifications_state (
+                owner_login, notification_kind, created_at_ms, source_login, source_bch_name,
+                source_block_number, source_block_hash, target_login, target_bch_name,
+                target_block_number, target_block_hash, source_msg_sub_type, source_text
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(owner_login, notification_kind, source_bch_name, source_block_number, source_block_hash) DO UPDATE SET
+                created_at_ms = EXCLUDED.created_at_ms,
+                source_login = EXCLUDED.source_login,
+                target_login = EXCLUDED.target_login,
+                target_bch_name = EXCLUDED.target_bch_name,
+                target_block_number = EXCLUDED.target_block_number,
+                target_block_hash = EXCLUDED.target_block_hash,
+                source_msg_sub_type = EXCLUDED.source_msg_sub_type,
+                source_text = EXCLUDED.source_text
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            int i = 1;
+            ps.setString(i++, e.getOwnerLogin());
+            ps.setString(i++, e.getNotificationKind());
+            ps.setLong(i++, e.getCreatedAtMs());
+            ps.setString(i++, e.getSourceLogin());
+            ps.setString(i++, e.getSourceBchName());
+            ps.setInt(i++, e.getSourceBlockNumber());
+            ps.setBytes(i++, e.getSourceBlockHash());
+            if (e.getTargetLogin() != null) ps.setString(i++, e.getTargetLogin()); else ps.setNull(i++, Types.VARCHAR);
+            if (e.getTargetBchName() != null) ps.setString(i++, e.getTargetBchName()); else ps.setNull(i++, Types.VARCHAR);
+            if (e.getTargetBlockNumber() != null) ps.setInt(i++, e.getTargetBlockNumber()); else ps.setNull(i++, Types.INTEGER);
+            if (e.getTargetBlockHash() != null) ps.setBytes(i++, e.getTargetBlockHash()); else ps.setNull(i++, Types.BINARY);
+            ps.setInt(i++, e.getSourceMsgSubType());
+            ps.setString(i++, e.getSourceText() == null ? "" : e.getSourceText());
+            return ps.executeUpdate();
+        }
+    }
+
+    public List<UserNotificationEntry> listByOwnerAndKind(Connection c, String ownerLogin, String kind, int limit) throws SQLException {
+        String sql = """
+            SELECT owner_login, notification_kind, created_at_ms, source_login, source_bch_name,
+                   source_block_number, source_block_hash, target_login, target_bch_name,
+                   target_block_number, target_block_hash, source_msg_sub_type, source_text
+            FROM user_notifications_state
+            WHERE owner_login = ? AND notification_kind = ?
+            ORDER BY created_at_ms DESC, source_block_number DESC
+            LIMIT ?
+            """;
+        List<UserNotificationEntry> out = new ArrayList<>();
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, ownerLogin);
+            ps.setString(2, kind);
+            ps.setInt(3, Math.max(1, limit));
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) out.add(mapRow(rs));
+            }
+        }
+        return out;
+    }
+
+    private static UserNotificationEntry mapRow(ResultSet rs) throws SQLException {
+        UserNotificationEntry e = new UserNotificationEntry();
+        e.setOwnerLogin(rs.getString("owner_login"));
+        e.setNotificationKind(rs.getString("notification_kind"));
+        e.setCreatedAtMs(rs.getLong("created_at_ms"));
+        e.setSourceLogin(rs.getString("source_login"));
+        e.setSourceBchName(rs.getString("source_bch_name"));
+        e.setSourceBlockNumber(rs.getInt("source_block_number"));
+        e.setSourceBlockHash(rs.getBytes("source_block_hash"));
+        e.setTargetLogin(rs.getString("target_login"));
+        e.setTargetBchName(rs.getString("target_bch_name"));
+        Object targetBlockNumber = rs.getObject("target_block_number");
+        e.setTargetBlockNumber(targetBlockNumber == null ? null : ((Number) targetBlockNumber).intValue());
+        e.setTargetBlockHash(rs.getBytes("target_block_hash"));
+        e.setSourceMsgSubType(rs.getInt("source_msg_sub_type"));
+        e.setSourceText(rs.getString("source_text"));
+        return e;
+    }
+}

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserSettingsDAO.java

@@ -0,0 +1,231 @@
+package shine.db.dao;
+
+import shine.db.DbController;
+import shine.db.entities.UserSettingEntry;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * UserSettingsDAO — хранение пользовательских настроек.
+ *
+ * Правило:
+ * - уникальность: login + setting_type + setting_key
+ * - запись обновляется только если time_ms новее
+ * - synced=true означает, что значение уже дошло до второго сервера
+ */
+public final class UserSettingsDAO {
+
+    private static volatile UserSettingsDAO instance;
+    private final DbController db = DbController.getInstance();
+
+    private UserSettingsDAO() {}
+
+    public static UserSettingsDAO getInstance() {
+        if (instance == null) {
+            synchronized (UserSettingsDAO.class) {
+                if (instance == null) instance = new UserSettingsDAO();
+            }
+        }
+        return instance;
+    }
+
+    public int upsertIfNewer(Connection c, UserSettingEntry e) throws SQLException {
+        String sql = """
+            INSERT INTO user_settings (
+                login, setting_type, setting_key, time_ms,
+                value_text, value_num, client_key, signature, synced
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (login, setting_type, setting_key)
+            DO UPDATE SET
+                time_ms    = EXCLUDED.time_ms,
+                value_text = EXCLUDED.value_text,
+                value_num  = EXCLUDED.value_num,
+                client_key = EXCLUDED.client_key,
+                signature  = EXCLUDED.signature,
+                synced     = EXCLUDED.synced
+            WHERE user_settings.time_ms < EXCLUDED.time_ms
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, e.getLogin());
+            ps.setInt(2, e.getSettingType());
+            ps.setString(3, e.getSettingKey());
+            ps.setLong(4, e.getTimeMs());
+            ps.setString(5, e.getValueText() == null ? "" : e.getValueText());
+            ps.setLong(6, e.getValueNum());
+
+            if (e.getClientKey() == null || e.getClientKey().isBlank()) ps.setNull(7, Types.VARCHAR);
+            else ps.setString(7, e.getClientKey());
+
+            if (e.getSignature() == null || e.getSignature().isBlank()) ps.setNull(8, Types.VARCHAR);
+            else ps.setString(8, e.getSignature());
+
+            ps.setBoolean(9, e.isSynced());
+            return ps.executeUpdate();
+        }
+    }
+
+    public int upsertIfNewer(UserSettingEntry e) throws SQLException {
+        try (Connection c = db.getConnection()) {
+            return upsertIfNewer(c, e);
+        }
+    }
+
+    public UserSettingEntry getByLoginTypeKey(Connection c, String login, int settingType, String settingKey) throws SQLException {
+        String sql = """
+            SELECT login, setting_type, setting_key, time_ms, value_text, value_num, client_key, signature, synced
+            FROM user_settings
+            WHERE LOWER(login) = LOWER(?) AND setting_type = ? AND setting_key = ?
+            LIMIT 1
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, login);
+            ps.setInt(2, settingType);
+            ps.setString(3, settingKey);
+            try (ResultSet rs = ps.executeQuery()) {
+                return rs.next() ? mapRow(rs) : null;
+            }
+        }
+    }
+
+    public UserSettingEntry getByLoginTypeKey(String login, int settingType, String settingKey) throws SQLException {
+        try (Connection c = db.getConnection()) {
+            return getByLoginTypeKey(c, login, settingType, settingKey);
+        }
+    }
+
+    public List<UserSettingEntry> getByLogin(Connection c, String login) throws SQLException {
+        String sql = """
+            SELECT login, setting_type, setting_key, time_ms, value_text, value_num, client_key, signature, synced
+            FROM user_settings
+            WHERE LOWER(login) = LOWER(?)
+            ORDER BY time_ms DESC, setting_type ASC, setting_key ASC
+            """;
+        List<UserSettingEntry> out = new ArrayList<>();
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, login);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) out.add(mapRow(rs));
+            }
+        }
+        return out;
+    }
+
+    public List<UserSettingEntry> getByLogin(String login) throws SQLException {
+        try (Connection c = db.getConnection()) {
+            return getByLogin(c, login);
+        }
+    }
+
+    public List<UserSettingEntry> listNewerThan(Connection c, String login, long afterTimeMs, String afterSettingKey, int limit) throws SQLException {
+        String sql = """
+            SELECT login, setting_type, setting_key, time_ms, value_text, value_num, client_key, signature, synced
+            FROM user_settings
+            WHERE LOWER(login) = LOWER(?)
+              AND (
+                    time_ms > ?
+                 OR (time_ms = ? AND setting_key > ?)
+              )
+            ORDER BY time_ms ASC, setting_key ASC
+            LIMIT ?
+            """;
+        List<UserSettingEntry> out = new ArrayList<>();
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, login);
+            ps.setLong(2, Math.max(0L, afterTimeMs));
+            ps.setLong(3, Math.max(0L, afterTimeMs));
+            ps.setString(4, afterSettingKey == null ? "" : afterSettingKey);
+            ps.setInt(5, Math.max(1, limit));
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) out.add(mapRow(rs));
+            }
+        }
+        return out;
+    }
+
+    public List<UserSettingEntry> listUnsyncedByLogin(Connection c, String login, int limit) throws SQLException {
+        String sql = """
+            SELECT login, setting_type, setting_key, time_ms, value_text, value_num, client_key, signature, synced
+            FROM user_settings
+            WHERE LOWER(login) = LOWER(?)
+              AND synced = FALSE
+            ORDER BY time_ms ASC, setting_key ASC
+            LIMIT ?
+            """;
+        List<UserSettingEntry> out = new ArrayList<>();
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, login);
+            ps.setInt(2, Math.max(1, limit));
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) out.add(mapRow(rs));
+            }
+        }
+        return out;
+    }
+
+    public int markSynced(Connection c, String login, int settingType, String settingKey) throws SQLException {
+        String sql = """
+            UPDATE user_settings
+            SET synced = TRUE
+            WHERE LOWER(login) = LOWER(?)
+              AND setting_type = ?
+              AND setting_key = ?
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, login);
+            ps.setInt(2, settingType);
+            ps.setString(3, settingKey);
+            return ps.executeUpdate();
+        }
+    }
+
+    public int markAllUnsynced(Connection c, String login) throws SQLException {
+        String sql = """
+            UPDATE user_settings
+            SET synced = FALSE
+            WHERE LOWER(login) = LOWER(?)
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, login);
+            return ps.executeUpdate();
+        }
+    }
+
+    public int markAllUnsynced() throws SQLException {
+        try (Connection c = db.getConnection()) {
+            return markAllUnsynced(c);
+        }
+    }
+
+    public int markAllUnsynced(Connection c) throws SQLException {
+        try (PreparedStatement ps = c.prepareStatement("UPDATE user_settings SET synced = FALSE")) {
+            return ps.executeUpdate();
+        }
+    }
+
+    private static UserSettingEntry mapRow(ResultSet rs) throws SQLException {
+        UserSettingEntry e = new UserSettingEntry();
+        e.setLogin(rs.getString("login"));
+        e.setSettingType(rs.getInt("setting_type"));
+        e.setSettingKey(rs.getString("setting_key"));
+        e.setTimeMs(rs.getLong("time_ms"));
+        e.setValueText(rs.getString("value_text"));
+        e.setValueNum(rs.getLong("value_num"));
+
+        String clientKey = rs.getString("client_key");
+        if (rs.wasNull()) clientKey = null;
+        e.setClientKey(clientKey);
+
+        String signature = rs.getString("signature");
+        if (rs.wasNull()) signature = null;
+        e.setSignature(signature);
+
+        e.setSynced(rs.getBoolean("synced"));
+        return e;
+    }
+}

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserSettingsSyncPeerStateDAO.java

@@ -0,0 +1,152 @@
+package shine.db.dao;
+
+import shine.db.DbController;
+import shine.db.entities.UserSettingsSyncPeerStateEntry;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public final class UserSettingsSyncPeerStateDAO {
+
+    private static volatile UserSettingsSyncPeerStateDAO instance;
+    private final DbController db = DbController.getInstance();
+
+    private UserSettingsSyncPeerStateDAO() {}
+
+    public static UserSettingsSyncPeerStateDAO getInstance() {
+        if (instance == null) {
+            synchronized (UserSettingsSyncPeerStateDAO.class) {
+                if (instance == null) instance = new UserSettingsSyncPeerStateDAO();
+            }
+        }
+        return instance;
+    }
+
+    public UserSettingsSyncPeerStateEntry getOrCreate(Connection c, String ownerLogin, String remoteServerLogin, String remoteServerUrl) throws SQLException {
+        UserSettingsSyncPeerStateEntry existing = get(c, ownerLogin, remoteServerLogin);
+        if (existing != null) return existing;
+        long nowMs = System.currentTimeMillis();
+        String sql = """
+            INSERT INTO user_settings_sync_peer_state (
+                owner_login, remote_server_login, remote_server_url,
+                cursor_time_ms, cursor_setting_key, bootstrap_completed,
+                last_sync_at_ms, last_error, updated_at_ms
+            ) VALUES (?, ?, ?, 0, '', FALSE, NULL, NULL, ?)
+            ON CONFLICT (owner_login, remote_server_login) DO UPDATE SET
+                remote_server_url = EXCLUDED.remote_server_url,
+                updated_at_ms = EXCLUDED.updated_at_ms
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, ownerLogin);
+            ps.setString(2, remoteServerLogin);
+            ps.setString(3, remoteServerUrl);
+            ps.setLong(4, nowMs);
+            ps.executeUpdate();
+        }
+        return get(c, ownerLogin, remoteServerLogin);
+    }
+
+    public UserSettingsSyncPeerStateEntry get(Connection c, String ownerLogin, String remoteServerLogin) throws SQLException {
+        String sql = """
+            SELECT owner_login, remote_server_login, remote_server_url, cursor_time_ms, cursor_setting_key,
+                   bootstrap_completed, last_sync_at_ms, last_error, updated_at_ms
+            FROM user_settings_sync_peer_state
+            WHERE LOWER(owner_login) = LOWER(?) AND LOWER(remote_server_login) = LOWER(?)
+            LIMIT 1
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, ownerLogin);
+            ps.setString(2, remoteServerLogin);
+            try (ResultSet rs = ps.executeQuery()) {
+                return rs.next() ? mapRow(rs) : null;
+            }
+        }
+    }
+
+    public int updateSuccess(String ownerLogin, String remoteServerLogin, String remoteServerUrl, long cursorTimeMs, String cursorSettingKey, boolean bootstrapCompleted) throws SQLException {
+        try (Connection c = db.getConnection()) {
+            String sql = """
+                INSERT INTO user_settings_sync_peer_state (
+                    owner_login, remote_server_login, remote_server_url,
+                    cursor_time_ms, cursor_setting_key, bootstrap_completed,
+                    last_sync_at_ms, last_error, updated_at_ms
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?)
+                ON CONFLICT (owner_login, remote_server_login) DO UPDATE SET
+                    remote_server_url = EXCLUDED.remote_server_url,
+                    cursor_time_ms = EXCLUDED.cursor_time_ms,
+                    cursor_setting_key = EXCLUDED.cursor_setting_key,
+                    bootstrap_completed = EXCLUDED.bootstrap_completed,
+                    last_sync_at_ms = EXCLUDED.last_sync_at_ms,
+                    last_error = NULL,
+                    updated_at_ms = EXCLUDED.updated_at_ms
+                """;
+            try (PreparedStatement ps = c.prepareStatement(sql)) {
+                long nowMs = System.currentTimeMillis();
+                ps.setString(1, ownerLogin);
+                ps.setString(2, remoteServerLogin);
+                ps.setString(3, remoteServerUrl);
+                ps.setLong(4, Math.max(0L, cursorTimeMs));
+                ps.setString(5, cursorSettingKey == null ? "" : cursorSettingKey);
+                ps.setBoolean(6, bootstrapCompleted);
+                ps.setLong(7, nowMs);
+                ps.setLong(8, nowMs);
+                return ps.executeUpdate();
+            }
+        }
+    }
+
+    public int updateError(String ownerLogin, String remoteServerLogin, String remoteServerUrl, String error) throws SQLException {
+        try (Connection c = db.getConnection()) {
+            String sql = """
+                INSERT INTO user_settings_sync_peer_state (
+                    owner_login, remote_server_login, remote_server_url,
+                    cursor_time_ms, cursor_setting_key, bootstrap_completed,
+                    last_sync_at_ms, last_error, updated_at_ms
+                ) VALUES (?, ?, ?, 0, '', FALSE, NULL, ?, ?)
+                ON CONFLICT (owner_login, remote_server_login) DO UPDATE SET
+                    remote_server_url = EXCLUDED.remote_server_url,
+                    last_error = EXCLUDED.last_error,
+                    updated_at_ms = EXCLUDED.updated_at_ms
+                """;
+            try (PreparedStatement ps = c.prepareStatement(sql)) {
+                long nowMs = System.currentTimeMillis();
+                ps.setString(1, ownerLogin);
+                ps.setString(2, remoteServerLogin);
+                ps.setString(3, remoteServerUrl);
+                ps.setString(4, error);
+                ps.setLong(5, nowMs);
+                return ps.executeUpdate();
+            }
+        }
+    }
+
+    public int clearBootstrap(String ownerLogin, String remoteServerLogin, String remoteServerUrl) throws SQLException {
+        return updateSuccess(ownerLogin, remoteServerLogin, remoteServerUrl, 0L, "", false);
+    }
+
+    public int deleteAllForOwner(String ownerLogin) throws SQLException {
+        try (Connection c = db.getConnection()) {
+            try (PreparedStatement ps = c.prepareStatement("DELETE FROM user_settings_sync_peer_state WHERE LOWER(owner_login) = LOWER(?)")) {
+                ps.setString(1, ownerLogin);
+                return ps.executeUpdate();
+            }
+        }
+    }
+
+    private static UserSettingsSyncPeerStateEntry mapRow(ResultSet rs) throws SQLException {
+        UserSettingsSyncPeerStateEntry e = new UserSettingsSyncPeerStateEntry();
+        e.setOwnerLogin(rs.getString("owner_login"));
+        e.setRemoteServerLogin(rs.getString("remote_server_login"));
+        e.setRemoteServerUrl(rs.getString("remote_server_url"));
+        e.setCursorTimeMs(rs.getLong("cursor_time_ms"));
+        e.setCursorSettingKey(rs.getString("cursor_setting_key"));
+        e.setBootstrapCompleted(rs.getBoolean("bootstrap_completed"));
+        long lastSyncAtMs = rs.getLong("last_sync_at_ms");
+        e.setLastSyncAtMs(rs.wasNull() ? null : lastSyncAtMs);
+        e.setLastError(rs.getString("last_error"));
+        e.setUpdatedAtMs(rs.getLong("updated_at_ms"));
+        return e;
+    }
+}

SHiNE-server/shine-server-db/src/main/java/shine/db/entities/DirectMessageEntry.java

@@ -1,24 +0,0 @@
-package shine.db.entities;
-
-public class DirectMessageEntry {
-    private String messageId;
-    private String fromLogin;
-    private String toLogin;
-    private String text;
-    private long createdAtMs;
-
-    public String getMessageId() { return messageId; }
-    public void setMessageId(String messageId) { this.messageId = messageId; }
-
-    public String getFromLogin() { return fromLogin; }
-    public void setFromLogin(String fromLogin) { this.fromLogin = fromLogin; }
-
-    public String getToLogin() { return toLogin; }
-    public void setToLogin(String toLogin) { this.toLogin = toLogin; }
-
-    public String getText() { return text; }
-    public void setText(String text) { this.text = text; }
-
-    public long getCreatedAtMs() { return createdAtMs; }
-    public void setCreatedAtMs(long createdAtMs) { this.createdAtMs = createdAtMs; }
-}

SHiNE-server/shine-server-db/src/main/java/shine/db/entities/SignedDirectMessageHistoryEntry.java

@@ -1,35 +0,0 @@
-package shine.db.entities;
-
-public class SignedDirectMessageHistoryEntry {
-    private String messageId;
-    private String fromLogin;
-    private String toLogin;
-    private int targetMode;
-    private String targetSessionId;
-    private int messageType;
-    private long timeMs;
-    private long nonce;
-    private byte[] rawPacket;
-    private long createdAtMs;
-
-    public String getMessageId() { return messageId; }
-    public void setMessageId(String messageId) { this.messageId = messageId; }
-    public String getFromLogin() { return fromLogin; }
-    public void setFromLogin(String fromLogin) { this.fromLogin = fromLogin; }
-    public String getToLogin() { return toLogin; }
-    public void setToLogin(String toLogin) { this.toLogin = toLogin; }
-    public int getTargetMode() { return targetMode; }
-    public void setTargetMode(int targetMode) { this.targetMode = targetMode; }
-    public String getTargetSessionId() { return targetSessionId; }
-    public void setTargetSessionId(String targetSessionId) { this.targetSessionId = targetSessionId; }
-    public int getMessageType() { return messageType; }
-    public void setMessageType(int messageType) { this.messageType = messageType; }
-    public long getTimeMs() { return timeMs; }
-    public void setTimeMs(long timeMs) { this.timeMs = timeMs; }
-    public long getNonce() { return nonce; }
-    public void setNonce(long nonce) { this.nonce = nonce; }
-    public byte[] getRawPacket() { return rawPacket; }
-    public void setRawPacket(byte[] rawPacket) { this.rawPacket = rawPacket; }
-    public long getCreatedAtMs() { return createdAtMs; }
-    public void setCreatedAtMs(long createdAtMs) { this.createdAtMs = createdAtMs; }
-}

SHiNE-server/shine-server-db/src/main/java/shine/db/entities/UserNotificationEntry.java

@@ -0,0 +1,44 @@
+package shine.db.entities;
+
+public class UserNotificationEntry {
+    private String ownerLogin;
+    private String notificationKind;
+    private long createdAtMs;
+    private String sourceLogin;
+    private String sourceBchName;
+    private int sourceBlockNumber;
+    private byte[] sourceBlockHash;
+    private String targetLogin;
+    private String targetBchName;
+    private Integer targetBlockNumber;
+    private byte[] targetBlockHash;
+    private int sourceMsgSubType;
+    private String sourceText;
+
+    public String getOwnerLogin() { return ownerLogin; }
+    public void setOwnerLogin(String ownerLogin) { this.ownerLogin = ownerLogin; }
+    public String getNotificationKind() { return notificationKind; }
+    public void setNotificationKind(String notificationKind) { this.notificationKind = notificationKind; }
+    public long getCreatedAtMs() { return createdAtMs; }
+    public void setCreatedAtMs(long createdAtMs) { this.createdAtMs = createdAtMs; }
+    public String getSourceLogin() { return sourceLogin; }
+    public void setSourceLogin(String sourceLogin) { this.sourceLogin = sourceLogin; }
+    public String getSourceBchName() { return sourceBchName; }
+    public void setSourceBchName(String sourceBchName) { this.sourceBchName = sourceBchName; }
+    public int getSourceBlockNumber() { return sourceBlockNumber; }
+    public void setSourceBlockNumber(int sourceBlockNumber) { this.sourceBlockNumber = sourceBlockNumber; }
+    public byte[] getSourceBlockHash() { return sourceBlockHash; }
+    public void setSourceBlockHash(byte[] sourceBlockHash) { this.sourceBlockHash = sourceBlockHash; }
+    public String getTargetLogin() { return targetLogin; }
+    public void setTargetLogin(String targetLogin) { this.targetLogin = targetLogin; }
+    public String getTargetBchName() { return targetBchName; }
+    public void setTargetBchName(String targetBchName) { this.targetBchName = targetBchName; }
+    public Integer getTargetBlockNumber() { return targetBlockNumber; }
+    public void setTargetBlockNumber(Integer targetBlockNumber) { this.targetBlockNumber = targetBlockNumber; }
+    public byte[] getTargetBlockHash() { return targetBlockHash; }
+    public void setTargetBlockHash(byte[] targetBlockHash) { this.targetBlockHash = targetBlockHash; }
+    public int getSourceMsgSubType() { return sourceMsgSubType; }
+    public void setSourceMsgSubType(int sourceMsgSubType) { this.sourceMsgSubType = sourceMsgSubType; }
+    public String getSourceText() { return sourceText; }
+    public void setSourceText(String sourceText) { this.sourceText = sourceText; }
+}

SHiNE-server/shine-server-db/src/main/java/shine/db/entities/UserSettingEntry.java

@@ -0,0 +1,68 @@
+package shine.db.entities;
+
+/**
+ * UserSettingEntry — одна пользовательская настройка.
+ *
+ * Таблица: user_settings
+ *  - login         TEXT    NOT NULL
+ *  - setting_type  INTEGER NOT NULL
+ *  - setting_key   TEXT    NOT NULL
+ *  - time_ms       BIGINT  NOT NULL
+ *  - value_text    TEXT    NOT NULL
+ *  - value_num     BIGINT  NOT NULL
+ *  - client_key    TEXT    NOT NULL
+ *  - signature     TEXT    NOT NULL
+ *  - synced        BOOLEAN NOT NULL
+ */
+public class UserSettingEntry {
+    private String login;
+    private int settingType;
+    private String settingKey;
+    private long timeMs;
+    private String valueText;
+    private long valueNum;
+    private String clientKey;
+    private String signature;
+    private boolean synced;
+
+    public UserSettingEntry() {}
+
+    public UserSettingEntry(String login, int settingType, String settingKey, long timeMs, String valueText, long valueNum, String clientKey, String signature, boolean synced) {
+        this.login = login;
+        this.settingType = settingType;
+        this.settingKey = settingKey;
+        this.timeMs = timeMs;
+        this.valueText = valueText;
+        this.valueNum = valueNum;
+        this.clientKey = clientKey;
+        this.signature = signature;
+        this.synced = synced;
+    }
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+
+    public int getSettingType() { return settingType; }
+    public void setSettingType(int settingType) { this.settingType = settingType; }
+
+    public String getSettingKey() { return settingKey; }
+    public void setSettingKey(String settingKey) { this.settingKey = settingKey; }
+
+    public long getTimeMs() { return timeMs; }
+    public void setTimeMs(long timeMs) { this.timeMs = timeMs; }
+
+    public String getValueText() { return valueText; }
+    public void setValueText(String valueText) { this.valueText = valueText; }
+
+    public long getValueNum() { return valueNum; }
+    public void setValueNum(long valueNum) { this.valueNum = valueNum; }
+
+    public String getClientKey() { return clientKey; }
+    public void setClientKey(String clientKey) { this.clientKey = clientKey; }
+
+    public String getSignature() { return signature; }
+    public void setSignature(String signature) { this.signature = signature; }
+
+    public boolean isSynced() { return synced; }
+    public void setSynced(boolean synced) { this.synced = synced; }
+}

SHiNE-server/shine-server-db/src/main/java/shine/db/entities/UserSettingsSyncPeerStateEntry.java

@@ -0,0 +1,40 @@
+package shine.db.entities;
+
+public class UserSettingsSyncPeerStateEntry {
+    private String ownerLogin;
+    private String remoteServerLogin;
+    private String remoteServerUrl;
+    private long cursorTimeMs;
+    private String cursorSettingKey;
+    private boolean bootstrapCompleted;
+    private Long lastSyncAtMs;
+    private String lastError;
+    private long updatedAtMs;
+
+    public String getOwnerLogin() { return ownerLogin; }
+    public void setOwnerLogin(String ownerLogin) { this.ownerLogin = ownerLogin; }
+
+    public String getRemoteServerLogin() { return remoteServerLogin; }
+    public void setRemoteServerLogin(String remoteServerLogin) { this.remoteServerLogin = remoteServerLogin; }
+
+    public String getRemoteServerUrl() { return remoteServerUrl; }
+    public void setRemoteServerUrl(String remoteServerUrl) { this.remoteServerUrl = remoteServerUrl; }
+
+    public long getCursorTimeMs() { return cursorTimeMs; }
+    public void setCursorTimeMs(long cursorTimeMs) { this.cursorTimeMs = cursorTimeMs; }
+
+    public String getCursorSettingKey() { return cursorSettingKey; }
+    public void setCursorSettingKey(String cursorSettingKey) { this.cursorSettingKey = cursorSettingKey; }
+
+    public boolean isBootstrapCompleted() { return bootstrapCompleted; }
+    public void setBootstrapCompleted(boolean bootstrapCompleted) { this.bootstrapCompleted = bootstrapCompleted; }
+
+    public Long getLastSyncAtMs() { return lastSyncAtMs; }
+    public void setLastSyncAtMs(Long lastSyncAtMs) { this.lastSyncAtMs = lastSyncAtMs; }
+
+    public String getLastError() { return lastError; }
+    public void setLastError(String lastError) { this.lastError = lastError; }
+
+    public long getUpdatedAtMs() { return updatedAtMs; }
+    public void setUpdatedAtMs(long updatedAtMs) { this.updatedAtMs = updatedAtMs; }
+}

SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v10.sql

@@ -0,0 +1,32 @@
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS user_notifications_state (
+    owner_login           TEXT NOT NULL REFERENCES solana_user_pda_current(normalized_login),
+    notification_kind     TEXT NOT NULL CHECK (notification_kind IN ('reply', 'connection')),
+    created_at_ms         BIGINT NOT NULL,
+    source_login          TEXT NOT NULL,
+    source_bch_name       TEXT NOT NULL,
+    source_block_number   INTEGER NOT NULL CHECK (source_block_number >= 0),
+    source_block_hash     BYTEA NOT NULL,
+    target_login          TEXT,
+    target_bch_name       TEXT,
+    target_block_number   INTEGER,
+    target_block_hash     BYTEA,
+    source_msg_sub_type   INTEGER NOT NULL,
+    source_text           TEXT NOT NULL DEFAULT '',
+    UNIQUE (owner_login, notification_kind, source_bch_name, source_block_number, source_block_hash)
+);
+
+CREATE INDEX IF NOT EXISTS idx_user_notifications_state_owner_kind_time
+    ON user_notifications_state(owner_login, notification_kind, created_at_ms DESC, source_block_number DESC);
+
+CREATE INDEX IF NOT EXISTS idx_user_notifications_state_owner_time
+    ON user_notifications_state(owner_login, created_at_ms DESC);
+
+INSERT INTO db_schema_version (id, schema_version, updated_at_ms)
+VALUES (1, 10, CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT))
+ON CONFLICT (id) DO UPDATE SET
+    schema_version = EXCLUDED.schema_version,
+    updated_at_ms = EXCLUDED.updated_at_ms;
+
+COMMIT;

SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v9.sql

@@ -0,0 +1,47 @@
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS user_settings (
+    login         TEXT NOT NULL REFERENCES solana_user_pda_current(login),
+    setting_type  INTEGER NOT NULL,
+    setting_key   TEXT NOT NULL,
+    time_ms       BIGINT NOT NULL,
+    value_text    TEXT NOT NULL DEFAULT '',
+    value_num     BIGINT NOT NULL DEFAULT 0,
+    client_key    TEXT NOT NULL DEFAULT '',
+    signature     TEXT NOT NULL DEFAULT '',
+    synced        BOOLEAN NOT NULL DEFAULT FALSE,
+    UNIQUE (login, setting_type, setting_key)
+);
+
+CREATE INDEX IF NOT EXISTS idx_user_settings_login
+    ON user_settings(login);
+
+CREATE INDEX IF NOT EXISTS idx_user_settings_synced
+    ON user_settings(login, synced, time_ms);
+
+CREATE INDEX IF NOT EXISTS idx_user_settings_type_key
+    ON user_settings(setting_type, setting_key);
+
+CREATE TABLE IF NOT EXISTS user_settings_sync_peer_state (
+    owner_login              TEXT NOT NULL,
+    remote_server_login      TEXT NOT NULL,
+    remote_server_url        TEXT NOT NULL,
+    cursor_time_ms           BIGINT NOT NULL DEFAULT 0,
+    cursor_setting_key       TEXT NOT NULL DEFAULT '',
+    bootstrap_completed      BOOLEAN NOT NULL DEFAULT FALSE,
+    last_sync_at_ms          BIGINT,
+    last_error               TEXT,
+    updated_at_ms            BIGINT NOT NULL,
+    PRIMARY KEY (owner_login, remote_server_login)
+);
+
+CREATE INDEX IF NOT EXISTS idx_user_settings_sync_peer_state_owner
+    ON user_settings_sync_peer_state(owner_login);
+
+INSERT INTO db_schema_version (id, schema_version, updated_at_ms)
+VALUES (1, 9, CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT))
+ON CONFLICT (id) DO UPDATE SET
+    schema_version = EXCLUDED.schema_version,
+    updated_at_ms = EXCLUDED.updated_at_ms;
+
+COMMIT;

SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql

@@ -22,7 +22,7 @@ CREATE TABLE IF NOT EXISTS db_schema_version (
 );
 
 INSERT INTO db_schema_version (id, schema_version, updated_at_ms)
-VALUES (1, 8, CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT))
+    VALUES (1, 9, CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT))
 ON CONFLICT (id) DO UPDATE SET
     schema_version = EXCLUDED.schema_version,
     updated_at_ms = EXCLUDED.updated_at_ms;
@@ -401,6 +401,44 @@ CREATE TABLE IF NOT EXISTS users_params (
 CREATE INDEX IF NOT EXISTS idx_users_params_login
     ON users_params(login);
 
+CREATE TABLE IF NOT EXISTS user_settings (
+    login         TEXT NOT NULL REFERENCES solana_user_pda_current(login),
+    setting_type  INTEGER NOT NULL,
+    setting_key   TEXT NOT NULL,
+    time_ms       BIGINT NOT NULL,
+    value_text    TEXT NOT NULL DEFAULT '',
+    value_num     BIGINT NOT NULL DEFAULT 0,
+    client_key    TEXT NOT NULL DEFAULT '',
+    signature     TEXT NOT NULL DEFAULT '',
+    synced        BOOLEAN NOT NULL DEFAULT FALSE,
+    UNIQUE (login, setting_type, setting_key)
+);
+
+CREATE INDEX IF NOT EXISTS idx_user_settings_login
+    ON user_settings(login);
+
+CREATE INDEX IF NOT EXISTS idx_user_settings_synced
+    ON user_settings(login, synced, time_ms);
+
+CREATE INDEX IF NOT EXISTS idx_user_settings_type_key
+    ON user_settings(setting_type, setting_key);
+
+CREATE TABLE IF NOT EXISTS user_settings_sync_peer_state (
+    owner_login              TEXT NOT NULL,
+    remote_server_login      TEXT NOT NULL,
+    remote_server_url        TEXT NOT NULL,
+    cursor_time_ms           BIGINT NOT NULL DEFAULT 0,
+    cursor_setting_key       TEXT NOT NULL DEFAULT '',
+    bootstrap_completed      BOOLEAN NOT NULL DEFAULT FALSE,
+    last_sync_at_ms          BIGINT,
+    last_error               TEXT,
+    updated_at_ms            BIGINT NOT NULL,
+    PRIMARY KEY (owner_login, remote_server_login)
+);
+
+CREATE INDEX IF NOT EXISTS idx_user_settings_sync_peer_state_owner
+    ON user_settings_sync_peer_state(owner_login);
+
 CREATE TABLE IF NOT EXISTS ip_geo_cache (
     ip             TEXT PRIMARY KEY,
     geo            TEXT,

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

@@ -60,6 +60,12 @@ import server.logic.ws_protocol.JSON.handlers.userParams.Net_UpsertUserParam_Han
 import server.logic.ws_protocol.JSON.handlers.userParams.entyties.Net_GetUserParam_Request;
 import server.logic.ws_protocol.JSON.handlers.userParams.entyties.Net_ListUserParams_Request;
 import server.logic.ws_protocol.JSON.handlers.userParams.entyties.Net_UpsertUserParam_Request;
+import server.logic.ws_protocol.JSON.handlers.userSettings.Net_GetUserSetting_Handler;
+import server.logic.ws_protocol.JSON.handlers.userSettings.Net_ListUserSettings_Handler;
+import server.logic.ws_protocol.JSON.handlers.userSettings.Net_UpsertUserSetting_Handler;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_GetUserSetting_Request;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_ListUserSettings_Request;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_UpsertUserSetting_Request;
 
 // --- NEW: connections friends lists ---
 import server.logic.ws_protocol.JSON.handlers.connections.Net_GetFriendsLists_Handler;
@@ -82,19 +88,22 @@ import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_ListSubscrip
 import server.logic.ws_protocol.JSON.handlers.connections.Net_GetUserConnectionsGraph_Handler;
 import server.logic.ws_protocol.JSON.handlers.connections.Net_AddCloseFriend_Handler;
 import server.logic.ws_protocol.JSON.handlers.connections.Net_ListContacts_Handler;
+import server.logic.ws_protocol.JSON.handlers.notifications.Net_GetNotifications_Handler;
 import server.logic.ws_protocol.JSON.handlers.connections.entyties.Net_GetUserConnectionsGraph_Request;
 import server.logic.ws_protocol.JSON.handlers.connections.entyties.Net_AddCloseFriend_Request;
 import server.logic.ws_protocol.JSON.handlers.connections.entyties.Net_ListContacts_Request;
+import server.logic.ws_protocol.JSON.handlers.notifications.entyties.Net_GetNotifications_Request;
 import server.logic.ws_protocol.JSON.messages.Net_AckSessionDelivery_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_CallInviteBroadcast_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_CallSignalToSession_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_DeleteConversation_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_DeleteMessage_Handler;
+import server.logic.ws_protocol.JSON.messages.Net_MarkAllUserSettingsUnsynced_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_DmSyncBatch_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_GetDirectMessages_Handler;
+import server.logic.ws_protocol.JSON.messages.Net_UserSettingsSyncBatch_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_SendSignal_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_ReceiveIncomingMessage_Handler;
-import server.logic.ws_protocol.JSON.messages.Net_SendDirectMessage_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_SendMessagePair_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_SendTestWebPush_Handler;
 import server.logic.ws_protocol.JSON.messages.Net_UpsertPushToken_Handler;
@@ -103,11 +112,12 @@ import server.logic.ws_protocol.JSON.messages.entyties.Net_CallInviteBroadcast_R
 import server.logic.ws_protocol.JSON.messages.entyties.Net_CallSignalToSession_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_DeleteConversation_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_DeleteMessage_Request;
+import server.logic.ws_protocol.JSON.messages.entyties.Net_MarkAllUserSettingsUnsynced_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_DmSyncBatch_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_GetDirectMessages_Request;
+import server.logic.ws_protocol.JSON.messages.entyties.Net_UserSettingsSyncBatch_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_SendSignal_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_ReceiveIncomingMessage_Request;
-import server.logic.ws_protocol.JSON.messages.entyties.Net_SendDirectMessage_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_SendMessagePair_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_SendTestWebPush_Request;
 import server.logic.ws_protocol.JSON.messages.entyties.Net_UpsertPushToken_Request;
@@ -182,6 +192,11 @@ public final class JsonHandlerRegistry {
             Map.entry("GetUserParam",       new Net_GetUserParam_Handler()),
             Map.entry("ListUserParams",     new Net_ListUserParams_Handler()),
 
+            // --- userSettings ---
+            Map.entry("UpsertUserSetting",  new Net_UpsertUserSetting_Handler()),
+            Map.entry("GetUserSetting",     new Net_GetUserSetting_Handler()),
+            Map.entry("ListUserSettings",   new Net_ListUserSettings_Handler()),
+
             // --- connections ---
             Map.entry("GetFriendsLists",    new Net_GetFriendsLists_Handler()),
             Map.entry("ListSubscriptionsFeed", new Net_ListSubscriptionsFeed_Handler()),
@@ -194,6 +209,7 @@ public final class JsonHandlerRegistry {
             Map.entry("ListContacts", new Net_ListContacts_Handler()),
             Map.entry("GetUserConnectionsGraph", new Net_GetUserConnectionsGraph_Handler()),
             Map.entry("AddCloseFriend", new Net_AddCloseFriend_Handler()),
+            Map.entry("GetNotifications", new Net_GetNotifications_Handler()),
 
             // --- direct messages / push ---
             Map.entry("UpsertPushToken", new Net_UpsertPushToken_Handler()),
@@ -204,6 +220,8 @@ public final class JsonHandlerRegistry {
             Map.entry("DeleteMessage", new Net_DeleteMessage_Handler()),
             Map.entry("DeleteConversation", new Net_DeleteConversation_Handler()),
             Map.entry("DmSyncBatch", new Net_DmSyncBatch_Handler()),
+            Map.entry("UserSettingsSyncBatch", new Net_UserSettingsSyncBatch_Handler()),
+            Map.entry("MarkAllUserSettingsUnsynced", new Net_MarkAllUserSettingsUnsynced_Handler()),
             Map.entry("GetDirectMessages", new Net_GetDirectMessages_Handler()),
             Map.entry("AckSessionDelivery", new Net_AckSessionDelivery_Handler()),
             Map.entry("CallInviteBroadcast", new Net_CallInviteBroadcast_Handler()),
@@ -264,6 +282,11 @@ public final class JsonHandlerRegistry {
             Map.entry("GetUserParam",       Net_GetUserParam_Request.class),
             Map.entry("ListUserParams",     Net_ListUserParams_Request.class),
 
+            // --- userSettings ---
+            Map.entry("UpsertUserSetting",  Net_UpsertUserSetting_Request.class),
+            Map.entry("GetUserSetting",     Net_GetUserSetting_Request.class),
+            Map.entry("ListUserSettings",   Net_ListUserSettings_Request.class),
+
             // --- connections ---
             Map.entry("GetFriendsLists",    Net_GetFriendsLists_Request.class),
             Map.entry("ListSubscriptionsFeed", Net_ListSubscriptionsFeed_Request.class),
@@ -276,6 +299,7 @@ public final class JsonHandlerRegistry {
             Map.entry("ListContacts", Net_ListContacts_Request.class),
             Map.entry("GetUserConnectionsGraph", Net_GetUserConnectionsGraph_Request.class),
             Map.entry("AddCloseFriend", Net_AddCloseFriend_Request.class),
+            Map.entry("GetNotifications", Net_GetNotifications_Request.class),
 
             // --- direct messages / push ---
             Map.entry("UpsertPushToken", Net_UpsertPushToken_Request.class),
@@ -286,6 +310,8 @@ public final class JsonHandlerRegistry {
             Map.entry("DeleteMessage", Net_DeleteMessage_Request.class),
             Map.entry("DeleteConversation", Net_DeleteConversation_Request.class),
             Map.entry("DmSyncBatch", Net_DmSyncBatch_Request.class),
+            Map.entry("UserSettingsSyncBatch", Net_UserSettingsSyncBatch_Request.class),
+            Map.entry("MarkAllUserSettingsUnsynced", Net_MarkAllUserSettingsUnsynced_Request.class),
             Map.entry("GetDirectMessages", Net_GetDirectMessages_Request.class),
             Map.entry("AckSessionDelivery", Net_AckSessionDelivery_Request.class),
             Map.entry("CallInviteBroadcast", Net_CallInviteBroadcast_Request.class),

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java

@@ -5,8 +5,10 @@ import blockchain.BchCryptoVerifier;
 import blockchain.MsgSubType;
 import blockchain.body.BodyHasLine;
 import blockchain.body.BodyHasTarget;
+import blockchain.body.ConnectionBody;
 import blockchain.body.CreateChannelBody;
 import blockchain.body.StatusActionBody;
+import blockchain.body.TextReplyBody;
 import blockchain.body.TextLineBody;
 import blockchain.body.UserParamBody;
 import org.slf4j.Logger;
@@ -30,10 +32,12 @@ import shine.db.channels.ChannelNameRules;
 import shine.db.dao.BlockchainStateDAO;
 import shine.db.dao.BlocksDAO;
 import shine.db.dao.ChannelNameStateDAO;
+import shine.db.dao.UserNotificationsStateDAO;
 import shine.db.dao.UserParamsDAO;
 import shine.db.entities.BlockchainStateEntry;
 import shine.db.entities.BlockEntry;
 import shine.db.entities.ChannelNameStateEntry;
+import shine.db.entities.UserNotificationEntry;
 import shine.db.entities.UserParamEntry;
 import utils.blockchain.BlockchainNameUtil;
 
@@ -61,7 +65,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
     private final ChannelNameStateDAO channelNameStateDAO = ChannelNameStateDAO.getInstance();
     private final AddBlockSyncService addBlockSyncService = new AddBlockSyncService();
 
-    private final BlockchainWriter dbWriter = new BlockchainWriter(blocksDAO, stateDAO, userParamsDAO, channelNameStateDAO);
+    private final BlockchainWriter dbWriter = new BlockchainWriter(
+            blocksDAO, stateDAO, userParamsDAO, channelNameStateDAO, UserNotificationsStateDAO.getInstance());
 
     public Net_AddBlock_Handler() {
         ChannelNamesStateBootstrapper.bootstrapOrFailFast();
@@ -573,7 +578,9 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
                 );
             }
 
-            dbWriter.appendBlockAndState(blockchainName, block, st, be, upsertedParam, channelNameStateEntry, channelMetaUpdateEntry);
+            UserNotificationEntry notificationEntry = buildNotificationEntry(block, be);
+            dbWriter.appendBlockAndState(
+                    blockchainName, block, st, be, upsertedParam, channelNameStateEntry, channelMetaUpdateEntry, notificationEntry);
 
             if (chat200CreateSeed != null) {
                 upsertChat200StateFromCreate(chat200CreateSeed);
@@ -855,6 +862,66 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
         return b;
     }
 
+    private UserNotificationEntry buildNotificationEntry(BchBlockEntry block, BlockEntry storedEntry) {
+        if (block == null || storedEntry == null) return null;
+        if (storedEntry.getToLogin() == null || storedEntry.getToLogin().isBlank()) return null;
+
+        int msgType = block.type & 0xFFFF;
+        int msgSubType = block.subType & 0xFFFF;
+        long createdAtMs = block.timestamp * 1000L;
+        String ownerLogin = storedEntry.getToLogin();
+        String sourceLogin = storedEntry.getLogin();
+
+        // A user must never receive a notification for replying to their own message/thread.
+        if (ownerLogin.equalsIgnoreCase(sourceLogin)) return null;
+
+        if (msgType == 1
+                && msgSubType == (MsgSubType.TEXT_REPLY & 0xFFFF)
+                && block.body instanceof TextReplyBody replyBody) {
+            UserNotificationEntry entry = baseNotificationEntry(storedEntry, ownerLogin, createdAtMs, msgSubType);
+            entry.setNotificationKind("reply");
+            entry.setSourceText(replyBody.message == null ? "" : replyBody.message);
+            return entry;
+        }
+
+        // Connection notifications are intentionally modeled as a generic kind.
+        // Today only CONNECTION_CLOSE_FRIEND is indexed; future incoming connection types
+        // can reuse the same notification kind and expose their code via sourceMsgSubType.
+        if (msgType == 3
+                && msgSubType == (MsgSubType.CONNECTION_CLOSE_FRIEND & 0xFFFF)
+                && block.body instanceof ConnectionBody) {
+            UserNotificationEntry entry = baseNotificationEntry(storedEntry, ownerLogin, createdAtMs, msgSubType);
+            entry.setNotificationKind("connection");
+            entry.setSourceText("");
+            return entry;
+        }
+
+        return null;
+    }
+
+    private UserNotificationEntry baseNotificationEntry(BlockEntry storedEntry,
+                                                        String ownerLogin,
+                                                        long createdAtMs,
+                                                        int msgSubType) {
+        UserNotificationEntry entry = new UserNotificationEntry();
+        entry.setOwnerLogin(ownerLogin);
+        entry.setCreatedAtMs(createdAtMs);
+        entry.setSourceLogin(storedEntry.getLogin());
+        entry.setSourceBchName(blockchainNameFromEntry(storedEntry));
+        entry.setSourceBlockNumber(storedEntry.getBlockNumber());
+        entry.setSourceBlockHash(storedEntry.getBlockHash());
+        entry.setTargetLogin(storedEntry.getToLogin());
+        entry.setTargetBchName(storedEntry.getToBchName());
+        entry.setTargetBlockNumber(storedEntry.getToBlockNumber());
+        entry.setTargetBlockHash(storedEntry.getToBlockHash());
+        entry.setSourceMsgSubType(msgSubType);
+        return entry;
+    }
+
+    private String blockchainNameFromEntry(BlockEntry entry) {
+        return entry == null ? null : entry.getBchName();
+    }
+
     private static String toHex(byte[] bytes) {
         if (bytes == null) return "null";
         char[] HEX = "0123456789abcdef".toCharArray();

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler_utils/BlockchainWriter.java

@@ -5,10 +5,12 @@ import shine.db.dao.BlockchainStateDAO;
 import shine.db.dao.BlocksDAO;
 import shine.db.dao.ChannelNameStateDAO;
 import shine.db.dao.UserParamsDAO;
+import shine.db.dao.UserNotificationsStateDAO;
 import shine.db.entities.BlockchainStateEntry;
 import shine.db.entities.BlockEntry;
 import shine.db.entities.ChannelNameStateEntry;
 import shine.db.entities.UserParamEntry;
+import shine.db.entities.UserNotificationEntry;
 import utils.files.FileStoreUtil;
 
 import java.io.IOException;
@@ -41,16 +43,19 @@ public final class BlockchainWriter {
     private final BlockchainStateDAO stateDAO;
     private final ChannelNameStateDAO channelNameStateDAO;
     private final UserParamsDAO userParamsDAO;
+    private final UserNotificationsStateDAO userNotificationsStateDAO;
     private final FileStoreUtil fs = FileStoreUtil.getInstance();
 
     public BlockchainWriter(BlocksDAO blocksDAO,
                             BlockchainStateDAO stateDAO,
                             UserParamsDAO userParamsDAO,
-                            ChannelNameStateDAO channelNameStateDAO) {
+                            ChannelNameStateDAO channelNameStateDAO,
+                            UserNotificationsStateDAO userNotificationsStateDAO) {
         this.blocksDAO = blocksDAO;
         this.stateDAO = stateDAO;
         this.userParamsDAO = userParamsDAO;
         this.channelNameStateDAO = channelNameStateDAO;
+        this.userNotificationsStateDAO = userNotificationsStateDAO;
     }
 
     public void appendBlockAndState(String blockchainName,
@@ -59,7 +64,8 @@ public final class BlockchainWriter {
                                     BlockEntry be,
                                     UserParamEntry userParamEntry,
                                     ChannelNameStateEntry channelNameStateEntry,
-                                    ChannelNameStateEntry channelMetaUpdateEntry) throws SQLException {
+                                    ChannelNameStateEntry channelMetaUpdateEntry,
+                                    UserNotificationEntry notificationEntry) throws SQLException {
 
         long nowMs = System.currentTimeMillis();
         byte[] blockBytes = block.toBytes();
@@ -96,6 +102,12 @@ public final class BlockchainWriter {
                     channelNameStateDAO.updateMeta(c, channelMetaUpdateEntry);
                 }
 
+                // Notification projection is part of the same SQL transaction as the block.
+                // If notification indexing fails, the block/state write is rolled back as well.
+                if (notificationEntry != null) {
+                    userNotificationsStateDAO.upsert(c, notificationEntry);
+                }
+
                 c.commit();
                 committed = true;
             } catch (Exception e) {

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelsReadSupport.java

@@ -144,6 +144,40 @@ final class ChannelsReadSupport {
         }
     }
 
+    static String userSettingsChannelKey(String ownerBch, String channelName) {
+        String bch = ownerBch == null ? "" : ownerBch.trim();
+        String name = channelName == null ? "" : channelName.trim();
+        return bch + "/" + name;
+    }
+
+    static int countUnreadMessages(Connection c, String viewerLogin, String ownerBch, String channelName, int messagesCount) throws SQLException {
+        if (viewerLogin == null || viewerLogin.isBlank()) return 0;
+        String key = userSettingsChannelKey(ownerBch, channelName);
+        String sql = """
+            SELECT value_num
+            FROM user_settings
+            WHERE LOWER(login) = LOWER(?)
+              AND setting_type = ?
+              AND setting_key = ?
+            LIMIT 1
+            """;
+        long lastSeen = messagesCount;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, viewerLogin);
+            ps.setInt(2, 1);
+            ps.setString(3, key);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (rs.next()) {
+                    long value = rs.getLong("value_num");
+                    if (!rs.wasNull()) lastSeen = value;
+                }
+            }
+        }
+        if (lastSeen < 0) lastSeen = 0;
+        if (lastSeen > messagesCount) return 0;
+        return Math.max(0, messagesCount - (int) lastSeen);
+    }
+
     static PostBlock loadLastPost(Connection c, String ownerBch, int lineCode) throws SQLException {
         String sql = """
             SELECT login,bch_name,block_number,block_hash,block_bytes,this_line_number

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListSubscriptionsFeed_Handler.java

@@ -82,7 +82,7 @@ public class Net_ListSubscriptionsFeed_Handler implements JsonMessageHandler {
 
             row.setChannel(channelRef);
             row.setMessagesCount(ChannelsReadSupport.countPosts(c, key.ownerBch, key.rootNumber));
-            row.setUnreadCount(0);
+            row.setUnreadCount(ChannelsReadSupport.countUnreadMessages(c, viewerLogin, key.ownerBch, meta.channelName, row.getMessagesCount()));
 
             ChannelsReadSupport.PostBlock lastPost = ChannelsReadSupport.loadLastPost(c, key.ownerBch, key.rootNumber);
             if (lastPost != null) {

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/notifications/Net_GetNotifications_Handler.java

@@ -0,0 +1,94 @@
+package server.logic.ws_protocol.JSON.handlers.notifications;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.JSON.handlers.notifications.entyties.Net_GetNotifications_Request;
+import server.logic.ws_protocol.JSON.handlers.notifications.entyties.Net_GetNotifications_Response;
+import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.DbController;
+import shine.db.dao.UserNotificationsStateDAO;
+import shine.db.entities.UserNotificationEntry;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class Net_GetNotifications_Handler implements JsonMessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(Net_GetNotifications_Handler.class);
+
+    @Override
+    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
+        Net_GetNotifications_Request req = (Net_GetNotifications_Request) baseRequest;
+        if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getCurrentUser() == null) {
+            return NetExceptionResponseFactory.error(
+                    req,
+                    WireCodes.Status.UNVERIFIED,
+                    "NOT_AUTHENTICATED",
+                    "Операция доступна только для авторизованных пользователей"
+            );
+        }
+
+        String login = String.valueOf(ctx.getCurrentUser().getLogin() == null ? "" : ctx.getCurrentUser().getLogin()).trim();
+        if (login.isBlank()) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED, "NOT_AUTHENTICATED", "Не удалось определить авторизованного пользователя");
+        }
+
+        int limit = req.getLimit() == null ? 50 : Math.max(1, Math.min(200, req.getLimit()));
+
+        try (Connection c = DbController.getInstance().getConnection()) {
+            List<UserNotificationEntry> replyRows = UserNotificationsStateDAO.getInstance().listByOwnerAndKind(c, login, "reply", limit);
+            List<UserNotificationEntry> eventRows = UserNotificationsStateDAO.getInstance().listByOwnerAndKind(c, login, "connection", limit);
+
+            Net_GetNotifications_Response resp = new Net_GetNotifications_Response();
+            resp.setOp(req.getOp());
+            resp.setRequestId(req.getRequestId());
+            resp.setStatus(WireCodes.Status.OK);
+            resp.setLogin(login);
+            resp.setReplies(mapRows(replyRows));
+            resp.setEvents(mapRows(eventRows));
+            return resp;
+        } catch (Exception e) {
+            log.error("GetNotifications failed", e);
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR, "internal_error", "Внутренняя ошибка сервера");
+        }
+    }
+
+    private List<Net_GetNotifications_Response.NotificationItem> mapRows(List<UserNotificationEntry> rows) {
+        List<Net_GetNotifications_Response.NotificationItem> out = new ArrayList<>();
+        for (UserNotificationEntry row : rows) {
+            Net_GetNotifications_Response.NotificationItem item = new Net_GetNotifications_Response.NotificationItem();
+            item.setKind(row.getNotificationKind());
+            item.setCreatedAtMs(row.getCreatedAtMs());
+            item.setSourceLogin(row.getSourceLogin());
+            item.setSourceBlockchainName(row.getSourceBchName());
+            item.setSourceBlockNumber(row.getSourceBlockNumber());
+            item.setSourceBlockHash(bytesToHex(row.getSourceBlockHash()));
+            item.setSourceMsgSubType(row.getSourceMsgSubType());
+            item.setConnectionTypeCode("connection".equals(row.getNotificationKind()) ? row.getSourceMsgSubType() : null);
+            item.setSourceText(row.getSourceText());
+            item.setTargetLogin(row.getTargetLogin());
+            item.setTargetBlockchainName(row.getTargetBchName());
+            item.setTargetBlockNumber(row.getTargetBlockNumber());
+            item.setTargetBlockHash(bytesToHex(row.getTargetBlockHash()));
+            out.add(item);
+        }
+        return out;
+    }
+
+    private static String bytesToHex(byte[] bytes) {
+        if (bytes == null) return null;
+        char[] HEX = "0123456789abcdef".toCharArray();
+        char[] out = new char[bytes.length * 2];
+        for (int i = 0; i < bytes.length; i++) {
+            int v = bytes[i] & 0xff;
+            out[i * 2] = HEX[v >>> 4];
+            out[i * 2 + 1] = HEX[v & 0x0f];
+        }
+        return new String(out);
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/notifications/entyties/Net_GetNotifications_Request.java

@@ -0,0 +1,10 @@
+package server.logic.ws_protocol.JSON.handlers.notifications.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+
+public class Net_GetNotifications_Request extends Net_Request {
+    private Integer limit;
+
+    public Integer getLimit() { return limit; }
+    public void setLimit(Integer limit) { this.limit = limit; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/notifications/entyties/Net_GetNotifications_Response.java

@@ -0,0 +1,62 @@
+package server.logic.ws_protocol.JSON.handlers.notifications.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Net_GetNotifications_Response extends Net_Response {
+    private String login;
+    private List<NotificationItem> replies = new ArrayList<>();
+    private List<NotificationItem> events = new ArrayList<>();
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+    public List<NotificationItem> getReplies() { return replies; }
+    public void setReplies(List<NotificationItem> replies) { this.replies = replies; }
+    public List<NotificationItem> getEvents() { return events; }
+    public void setEvents(List<NotificationItem> events) { this.events = events; }
+
+    public static class NotificationItem {
+        private String kind;
+        private long createdAtMs;
+        private String sourceLogin;
+        private String sourceBlockchainName;
+        private int sourceBlockNumber;
+        private String sourceBlockHash;
+        private Integer sourceMsgSubType;
+        private Integer connectionTypeCode;
+        private String sourceText;
+        private String targetLogin;
+        private String targetBlockchainName;
+        private Integer targetBlockNumber;
+        private String targetBlockHash;
+
+        public String getKind() { return kind; }
+        public void setKind(String kind) { this.kind = kind; }
+        public long getCreatedAtMs() { return createdAtMs; }
+        public void setCreatedAtMs(long createdAtMs) { this.createdAtMs = createdAtMs; }
+        public String getSourceLogin() { return sourceLogin; }
+        public void setSourceLogin(String sourceLogin) { this.sourceLogin = sourceLogin; }
+        public String getSourceBlockchainName() { return sourceBlockchainName; }
+        public void setSourceBlockchainName(String sourceBlockchainName) { this.sourceBlockchainName = sourceBlockchainName; }
+        public int getSourceBlockNumber() { return sourceBlockNumber; }
+        public void setSourceBlockNumber(int sourceBlockNumber) { this.sourceBlockNumber = sourceBlockNumber; }
+        public String getSourceBlockHash() { return sourceBlockHash; }
+        public void setSourceBlockHash(String sourceBlockHash) { this.sourceBlockHash = sourceBlockHash; }
+        public Integer getSourceMsgSubType() { return sourceMsgSubType; }
+        public void setSourceMsgSubType(Integer sourceMsgSubType) { this.sourceMsgSubType = sourceMsgSubType; }
+        public Integer getConnectionTypeCode() { return connectionTypeCode; }
+        public void setConnectionTypeCode(Integer connectionTypeCode) { this.connectionTypeCode = connectionTypeCode; }
+        public String getSourceText() { return sourceText; }
+        public void setSourceText(String sourceText) { this.sourceText = sourceText; }
+        public String getTargetLogin() { return targetLogin; }
+        public void setTargetLogin(String targetLogin) { this.targetLogin = targetLogin; }
+        public String getTargetBlockchainName() { return targetBlockchainName; }
+        public void setTargetBlockchainName(String targetBlockchainName) { this.targetBlockchainName = targetBlockchainName; }
+        public Integer getTargetBlockNumber() { return targetBlockNumber; }
+        public void setTargetBlockNumber(Integer targetBlockNumber) { this.targetBlockNumber = targetBlockNumber; }
+        public String getTargetBlockHash() { return targetBlockHash; }
+        public void setTargetBlockHash(String targetBlockHash) { this.targetBlockHash = targetBlockHash; }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/Net_GetUserSetting_Handler.java

@@ -0,0 +1,64 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_GetUserSetting_Request;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_GetUserSetting_Response;
+import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.DbController;
+import shine.db.dao.CurrentUsersDAO;
+import shine.db.dao.UserSettingsDAO;
+import shine.db.entities.CurrentUserEntry;
+import shine.db.entities.UserSettingEntry;
+
+import java.sql.Connection;
+
+public class Net_GetUserSetting_Handler implements JsonMessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(Net_GetUserSetting_Handler.class);
+
+    @Override
+    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
+        Net_GetUserSetting_Request req = (Net_GetUserSetting_Request) baseRequest;
+        if (req.getLogin() == null || req.getLogin().isBlank()
+                || req.getSetting_type() == null
+                || req.getSetting_key() == null || req.getSetting_key().isBlank()) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "BAD_FIELDS", "Некорректные поля: login/setting_type/setting_key");
+        }
+
+        try (Connection c = DbController.getInstance().getConnection()) {
+            String login = CurrentUsersDAO.getInstance().getByLogin(c, req.getLogin().trim()) != null
+                    ? req.getLogin().trim()
+                    : null;
+            if (login == null) {
+                return NetExceptionResponseFactory.error(req, 404, "USER_NOT_FOUND", "Пользователь не найден");
+            }
+            UserSettingEntry entry = UserSettingsDAO.getInstance().getByLoginTypeKey(c, login, req.getSetting_type(), req.getSetting_key().trim());
+            if (entry == null) {
+                return NetExceptionResponseFactory.error(req, 404, "SETTING_NOT_FOUND", "Настройка не найдена");
+            }
+
+            Net_GetUserSetting_Response resp = new Net_GetUserSetting_Response();
+            resp.setOp(req.getOp());
+            resp.setRequestId(req.getRequestId());
+            resp.setStatus(WireCodes.Status.OK);
+            resp.setLogin(entry.getLogin());
+            resp.setSetting_type(entry.getSettingType());
+            resp.setSetting_key(entry.getSettingKey());
+            resp.setTime_ms(entry.getTimeMs());
+            resp.setValue_text(entry.getValueText());
+            resp.setValue_num(entry.getValueNum());
+            resp.setClient_key(entry.getClientKey());
+            resp.setSignature(entry.getSignature());
+            resp.setSynced(entry.isSynced());
+            return resp;
+        } catch (Exception e) {
+            log.error("GetUserSetting failed", e);
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR, "INTERNAL_ERROR", "Внутренняя ошибка сервера");
+        }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/Net_ListUserSettings_Handler.java

@@ -0,0 +1,68 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_ListUserSettings_Request;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_ListUserSettings_Response;
+import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.DbController;
+import shine.db.dao.CurrentUsersDAO;
+import shine.db.dao.UserSettingsDAO;
+import shine.db.entities.CurrentUserEntry;
+import shine.db.entities.UserSettingEntry;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Net_ListUserSettings_Handler implements JsonMessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(Net_ListUserSettings_Handler.class);
+
+    @Override
+    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
+        Net_ListUserSettings_Request req = (Net_ListUserSettings_Request) baseRequest;
+        if (req.getLogin() == null || req.getLogin().isBlank()) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "BAD_FIELDS", "Некорректные поля: login");
+        }
+
+        try (Connection c = DbController.getInstance().getConnection()) {
+            String login = req.getLogin().trim();
+            CurrentUserEntry user = CurrentUsersDAO.getInstance().getByLogin(c, login);
+            if (user == null) {
+                return NetExceptionResponseFactory.error(req, 404, "USER_NOT_FOUND", "Пользователь не найден");
+            }
+
+            List<UserSettingEntry> entries = UserSettingsDAO.getInstance().getByLogin(c, login);
+            List<Net_ListUserSettings_Response.Item> items = new ArrayList<>();
+            for (UserSettingEntry e : entries) {
+                Net_ListUserSettings_Response.Item item = new Net_ListUserSettings_Response.Item();
+                item.setLogin(e.getLogin());
+                item.setSetting_type(e.getSettingType());
+                item.setSetting_key(e.getSettingKey());
+                item.setTime_ms(e.getTimeMs());
+                item.setValue_text(e.getValueText());
+                item.setValue_num(e.getValueNum());
+                item.setClient_key(e.getClientKey());
+                item.setSignature(e.getSignature());
+                item.setSynced(e.isSynced());
+                items.add(item);
+            }
+
+            Net_ListUserSettings_Response resp = new Net_ListUserSettings_Response();
+            resp.setOp(req.getOp());
+            resp.setRequestId(req.getRequestId());
+            resp.setStatus(WireCodes.Status.OK);
+            resp.setLogin(user.getLogin());
+            resp.setSettings(items);
+            return resp;
+        } catch (Exception e) {
+            log.error("ListUserSettings failed", e);
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR, "INTERNAL_ERROR", "Внутренняя ошибка сервера");
+        }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/Net_UpsertUserSetting_Handler.java

@@ -0,0 +1,157 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.Base64Ws;
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_UpsertUserSetting_Request;
+import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_UpsertUserSetting_Response;
+import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
+import server.logic.ws_protocol.WireCodes;
+import server.sync.RemoteUserSettingsSyncClient;
+import shine.db.DbController;
+import shine.db.dao.CurrentUsersDAO;
+import shine.db.dao.UserAccessServersCurrentDAO;
+import shine.db.dao.UserSettingsDAO;
+import shine.db.entities.CurrentUserEntry;
+import shine.db.entities.UserAccessServerRouteEntry;
+import shine.db.entities.UserSettingEntry;
+import utils.config.ShineSignatureConstants;
+import utils.config.AppConfig;
+import utils.crypto.Ed25519Util;
+
+import java.nio.charset.StandardCharsets;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+
+public class Net_UpsertUserSetting_Handler implements JsonMessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(Net_UpsertUserSetting_Handler.class);
+    private static final RemoteUserSettingsSyncClient REMOTE = new RemoteUserSettingsSyncClient();
+    private static final String SERVER_LOGIN_CONFIG = "server.SHiNE.login";
+
+    @Override
+    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
+        Net_UpsertUserSetting_Request req = (Net_UpsertUserSetting_Request) baseRequest;
+        if (req.getLogin() == null || req.getLogin().isBlank()
+                || req.getSetting_type() == null
+                || req.getSetting_key() == null || req.getSetting_key().isBlank()
+                || req.getTime_ms() == null || req.getTime_ms() <= 0
+                || req.getClient_key() == null || req.getClient_key().isBlank()
+                || req.getSignature() == null || req.getSignature().isBlank()) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "BAD_FIELDS",
+                    "Некорректные поля: login/setting_type/setting_key/time_ms/client_key/signature");
+        }
+
+        String login = req.getLogin().trim();
+        int settingType = req.getSetting_type();
+        String settingKey = req.getSetting_key().trim();
+        long timeMs = req.getTime_ms();
+        String valueText = req.getValue_text() == null ? "" : req.getValue_text();
+        long valueNum = req.getValue_num() == null ? 0L : req.getValue_num();
+        String clientKeyB64 = req.getClient_key().trim();
+        String signatureB64 = req.getSignature().trim();
+        boolean syncDelivery = Boolean.TRUE.equals(req.getSync_delivery());
+
+        try {
+            byte[] pubKey32;
+            byte[] sig64;
+            try {
+                pubKey32 = Base64Ws.decodeLen(clientKeyB64, 32, "client_key");
+                sig64 = Base64Ws.decodeLen(signatureB64, 64, "signature");
+            } catch (IllegalArgumentException e) {
+                return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "BAD_BASE64", "client_key/signature должны быть Base64");
+            }
+
+            String signText = ShineSignatureConstants.USER_SETTINGS_PREFIX
+                    + escapePart(login) + '|'
+                    + settingType + '|'
+                    + escapePart(settingKey) + '|'
+                    + timeMs + '|'
+                    + escapePart(valueText) + '|'
+                    + valueNum;
+
+            if (!Ed25519Util.verify(signText.getBytes(StandardCharsets.UTF_8), sig64, pubKey32)) {
+                return NetExceptionResponseFactory.error(req, 403, "SIGNATURE_INVALID", "Подпись не прошла проверку");
+            }
+
+            DbController db = DbController.getInstance();
+            CurrentUsersDAO usersDAO = CurrentUsersDAO.getInstance();
+            UserSettingsDAO settingsDAO = UserSettingsDAO.getInstance();
+
+            try (Connection c = db.getConnection()) {
+                CurrentUserEntry user = usersDAO.getByLogin(c, login);
+                if (user == null) {
+                    return NetExceptionResponseFactory.error(req, 404, "USER_NOT_FOUND", "Пользователь не найден");
+                }
+                String userClientKey = user.getClientKey();
+                if (userClientKey == null || userClientKey.isBlank()) {
+                    return NetExceptionResponseFactory.error(req, WireCodes.Status.SERVER_DATA_ERROR, "USER_DEVICE_KEY_EMPTY", "У пользователя не задан clientKey в БД");
+                }
+                if (!userClientKey.trim().equals(clientKeyB64)) {
+                    return NetExceptionResponseFactory.error(req, 403, "DEVICE_KEY_MISMATCH", "client_key не соответствует пользователю");
+                }
+
+                UserSettingEntry entry = new UserSettingEntry(
+                        login,
+                        settingType,
+                        settingKey,
+                        timeMs,
+                        valueText,
+                        valueNum,
+                        clientKeyB64,
+                        signatureB64,
+                        syncDelivery
+                );
+                int changed = settingsDAO.upsertIfNewer(c, entry);
+
+                if (!syncDelivery && changed > 0) {
+                    int delivered = 0;
+                    String ownServerLogin = String.valueOf(AppConfig.getInstance().getParam(SERVER_LOGIN_CONFIG) == null ? "" : AppConfig.getInstance().getParam(SERVER_LOGIN_CONFIG)).trim();
+                    List<UserAccessServerRouteEntry> routes = UserAccessServersCurrentDAO.getInstance().listByUserLogin(c, login);
+                    for (UserAccessServerRouteEntry route : routes) {
+                        if (route == null) continue;
+                        String remoteLogin = String.valueOf(route.getServerLogin() == null ? "" : route.getServerLogin()).trim();
+                        String remoteUrl = String.valueOf(route.getServerUrl() == null ? "" : route.getServerUrl()).trim();
+                        if (remoteLogin.isBlank() || remoteUrl.isBlank()) continue;
+                        if (!ownServerLogin.isBlank() && remoteLogin.equalsIgnoreCase(ownServerLogin)) continue;
+                        try {
+                            REMOTE.upsertUserSetting(remoteUrl, entry, true);
+                            delivered++;
+                        } catch (Exception e) {
+                            log.warn("user_settings immediate sync failed: login={} remoteServer={} reason={}", login, remoteLogin, String.valueOf(e));
+                        }
+                    }
+                    if (delivered > 0 || routes.isEmpty()) {
+                        settingsDAO.markSynced(c, login, settingType, settingKey);
+                    }
+                }
+
+                Net_UpsertUserSetting_Response resp = new Net_UpsertUserSetting_Response();
+                resp.setOp(req.getOp());
+                resp.setRequestId(req.getRequestId());
+                resp.setStatus(WireCodes.Status.OK);
+                resp.setLogin(login);
+                resp.setSetting_type(settingType);
+                resp.setSetting_key(settingKey);
+                resp.setTime_ms(timeMs);
+                resp.setSynced(syncDelivery || changed == 0);
+                return resp;
+            }
+        } catch (SQLException e) {
+            log.error("UpsertUserSetting DB error", e);
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.SERVER_DATA_ERROR, "DB_ERROR", "Ошибка БД");
+        } catch (Exception e) {
+            log.error("UpsertUserSetting failed", e);
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR, "INTERNAL_ERROR", NetExceptionResponseFactory.detailedMessage("Внутренняя ошибка сервера при UpsertUserSetting", e));
+        }
+    }
+
+    private static String escapePart(String value) {
+        String s = String.valueOf(value == null ? "" : value);
+        return s.replace("\\", "\\\\").replace("|", "\\|");
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/entyties/Net_GetUserSetting_Request.java

@@ -0,0 +1,18 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+
+public class Net_GetUserSetting_Request extends Net_Request {
+    private String login;
+    private Integer setting_type;
+    private String setting_key;
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+
+    public Integer getSetting_type() { return setting_type; }
+    public void setSetting_type(Integer setting_type) { this.setting_type = setting_type; }
+
+    public String getSetting_key() { return setting_key; }
+    public void setSetting_key(String setting_key) { this.setting_key = setting_key; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/entyties/Net_GetUserSetting_Response.java

@@ -0,0 +1,42 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+
+public class Net_GetUserSetting_Response extends Net_Response {
+    private String login;
+    private Integer setting_type;
+    private String setting_key;
+    private Long time_ms;
+    private String value_text;
+    private Long value_num;
+    private String client_key;
+    private String signature;
+    private Boolean synced;
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+
+    public Integer getSetting_type() { return setting_type; }
+    public void setSetting_type(Integer setting_type) { this.setting_type = setting_type; }
+
+    public String getSetting_key() { return setting_key; }
+    public void setSetting_key(String setting_key) { this.setting_key = setting_key; }
+
+    public Long getTime_ms() { return time_ms; }
+    public void setTime_ms(Long time_ms) { this.time_ms = time_ms; }
+
+    public String getValue_text() { return value_text; }
+    public void setValue_text(String value_text) { this.value_text = value_text; }
+
+    public Long getValue_num() { return value_num; }
+    public void setValue_num(Long value_num) { this.value_num = value_num; }
+
+    public String getClient_key() { return client_key; }
+    public void setClient_key(String client_key) { this.client_key = client_key; }
+
+    public String getSignature() { return signature; }
+    public void setSignature(String signature) { this.signature = signature; }
+
+    public Boolean getSynced() { return synced; }
+    public void setSynced(Boolean synced) { this.synced = synced; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/entyties/Net_ListUserSettings_Request.java

@@ -0,0 +1,10 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+
+public class Net_ListUserSettings_Request extends Net_Request {
+    private String login;
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/entyties/Net_ListUserSettings_Response.java

@@ -0,0 +1,48 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Net_ListUserSettings_Response extends Net_Response {
+    private String login;
+    private List<Item> settings = new ArrayList<>();
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+
+    public List<Item> getSettings() { return settings; }
+    public void setSettings(List<Item> settings) { this.settings = settings; }
+
+    public static class Item {
+        private String login;
+        private Integer setting_type;
+        private String setting_key;
+        private Long time_ms;
+        private String value_text;
+        private Long value_num;
+        private String client_key;
+        private String signature;
+        private Boolean synced;
+
+        public String getLogin() { return login; }
+        public void setLogin(String login) { this.login = login; }
+        public Integer getSetting_type() { return setting_type; }
+        public void setSetting_type(Integer setting_type) { this.setting_type = setting_type; }
+        public String getSetting_key() { return setting_key; }
+        public void setSetting_key(String setting_key) { this.setting_key = setting_key; }
+        public Long getTime_ms() { return time_ms; }
+        public void setTime_ms(Long time_ms) { this.time_ms = time_ms; }
+        public String getValue_text() { return value_text; }
+        public void setValue_text(String value_text) { this.value_text = value_text; }
+        public Long getValue_num() { return value_num; }
+        public void setValue_num(Long value_num) { this.value_num = value_num; }
+        public String getClient_key() { return client_key; }
+        public void setClient_key(String client_key) { this.client_key = client_key; }
+        public String getSignature() { return signature; }
+        public void setSignature(String signature) { this.signature = signature; }
+        public Boolean getSynced() { return synced; }
+        public void setSynced(Boolean synced) { this.synced = synced; }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/entyties/Net_UpsertUserSetting_Request.java

@@ -0,0 +1,42 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+
+public class Net_UpsertUserSetting_Request extends Net_Request {
+    private String login;
+    private Integer setting_type;
+    private String setting_key;
+    private Long time_ms;
+    private String value_text;
+    private Long value_num;
+    private String client_key;
+    private String signature;
+    private Boolean sync_delivery;
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+
+    public Integer getSetting_type() { return setting_type; }
+    public void setSetting_type(Integer setting_type) { this.setting_type = setting_type; }
+
+    public String getSetting_key() { return setting_key; }
+    public void setSetting_key(String setting_key) { this.setting_key = setting_key; }
+
+    public Long getTime_ms() { return time_ms; }
+    public void setTime_ms(Long time_ms) { this.time_ms = time_ms; }
+
+    public String getValue_text() { return value_text; }
+    public void setValue_text(String value_text) { this.value_text = value_text; }
+
+    public Long getValue_num() { return value_num; }
+    public void setValue_num(Long value_num) { this.value_num = value_num; }
+
+    public String getClient_key() { return client_key; }
+    public void setClient_key(String client_key) { this.client_key = client_key; }
+
+    public String getSignature() { return signature; }
+    public void setSignature(String signature) { this.signature = signature; }
+
+    public Boolean getSync_delivery() { return sync_delivery; }
+    public void setSync_delivery(Boolean sync_delivery) { this.sync_delivery = sync_delivery; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/entyties/Net_UpsertUserSetting_Response.java

@@ -0,0 +1,26 @@
+package server.logic.ws_protocol.JSON.handlers.userSettings.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+
+public class Net_UpsertUserSetting_Response extends Net_Response {
+    private String login;
+    private Integer setting_type;
+    private String setting_key;
+    private Long time_ms;
+    private Boolean synced;
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+
+    public Integer getSetting_type() { return setting_type; }
+    public void setSetting_type(Integer setting_type) { this.setting_type = setting_type; }
+
+    public String getSetting_key() { return setting_key; }
+    public void setSetting_key(String setting_key) { this.setting_key = setting_key; }
+
+    public Long getTime_ms() { return time_ms; }
+    public void setTime_ms(Long time_ms) { this.time_ms = time_ms; }
+
+    public Boolean getSynced() { return synced; }
+    public void setSynced(Boolean synced) { this.synced = synced; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_MarkAllUserSettingsUnsynced_Handler.java

@@ -0,0 +1,42 @@
+package server.logic.ws_protocol.JSON.messages;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.JSON.messages.entyties.Net_MarkAllUserSettingsUnsynced_Request;
+import server.logic.ws_protocol.JSON.messages.entyties.Net_MarkAllUserSettingsUnsynced_Response;
+import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.DbController;
+import shine.db.dao.UserSettingsDAO;
+
+import java.sql.Connection;
+
+public class Net_MarkAllUserSettingsUnsynced_Handler implements JsonMessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(Net_MarkAllUserSettingsUnsynced_Handler.class);
+
+    @Override
+    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
+        Net_MarkAllUserSettingsUnsynced_Request req = (Net_MarkAllUserSettingsUnsynced_Request) baseRequest;
+        try (Connection c = DbController.getInstance().getConnection()) {
+            int updated;
+            if (req.getLogin() == null || req.getLogin().isBlank()) {
+                updated = UserSettingsDAO.getInstance().markAllUnsynced(c);
+            } else {
+                updated = UserSettingsDAO.getInstance().markAllUnsynced(c, req.getLogin().trim());
+            }
+            Net_MarkAllUserSettingsUnsynced_Response resp = new Net_MarkAllUserSettingsUnsynced_Response();
+            resp.setOp(req.getOp());
+            resp.setRequestId(req.getRequestId());
+            resp.setStatus(WireCodes.Status.OK);
+            resp.setUpdated(updated);
+            return resp;
+        } catch (Exception e) {
+            log.error("MarkAllUserSettingsUnsynced failed", e);
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR, "INTERNAL_ERROR", "Внутренняя ошибка сервера");
+        }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_SendDirectMessage_Handler.java

@@ -1,208 +0,0 @@
-package server.logic.ws_protocol.JSON.messages;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-import server.logic.ws_protocol.JSON.ActiveConnectionsRegistry;
-import server.logic.ws_protocol.JSON.ConnectionContext;
-import server.logic.ws_protocol.JSON.entyties.Net_Request;
-import server.logic.ws_protocol.JSON.entyties.Net_Response;
-import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
-import server.logic.ws_protocol.JSON.messages.entyties.Net_SendDirectMessage_Request;
-import server.logic.ws_protocol.JSON.messages.entyties.Net_SendDirectMessage_Response;
-import server.logic.ws_protocol.JSON.push.WebPushSender;
-import server.logic.ws_protocol.JSON.push.WsEventSender;
-import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
-import server.logic.ws_protocol.JSON.utils.NetIdGenerator;
-import server.logic.ws_protocol.WireCodes;
-import shine.db.dao.ActiveSessionsDAO;
-import shine.db.dao.DirectMessagesDAO;
-import shine.db.dao.SignedDirectMessagesHistoryDAO;
-import shine.db.dao.SignedDmReplayDAO;
-import shine.db.dao.CurrentUsersDAO;
-import shine.db.entities.ActiveSessionEntry;
-import shine.db.entities.DirectMessageEntry;
-import shine.db.entities.SignedDirectMessageHistoryEntry;
-import shine.db.entities.CurrentUserEntry;
-import utils.crypto.Ed25519Util;
-
-import java.nio.charset.StandardCharsets;
-import java.util.Base64;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.TimeUnit;
-
-public class Net_SendDirectMessage_Handler implements JsonMessageHandler {
-    private static final ObjectMapper MAPPER = new ObjectMapper();
-    private static final long REPLAY_TTL_MS = 15L * 60L * 1000L;
-    private static final int MAX_MESSAGE_BYTES = 3000;
-
-    @Override
-    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) throws Exception {
-        Net_SendDirectMessage_Request req = (Net_SendDirectMessage_Request) baseRequest;
-        if (req.getBlobB64() == null || req.getBlobB64().isBlank()) {
-            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "BAD_FIELDS", "blobB64 обязателен");
-        }
-
-        final byte[] raw;
-        final SignedDirectMessagePacket packet;
-        try {
-            raw = Base64.getDecoder().decode(req.getBlobB64().trim());
-            packet = SignedDirectMessagePacket.parse(raw, MAX_MESSAGE_BYTES);
-        } catch (IllegalArgumentException ex) {
-            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, ex.getMessage(), "Некорректный формат пакета");
-        }
-
-        CurrentUserEntry fromUser = CurrentUsersDAO.getInstance().getByLogin(packet.fromLogin);
-        CurrentUserEntry toUser = CurrentUsersDAO.getInstance().getByLogin(packet.toLogin);
-        if (fromUser == null || toUser == null) {
-            return NetExceptionResponseFactory.error(req, 404, "USER_NOT_FOUND", "from/to пользователь не найден");
-        }
-
-        byte[] publicKey32;
-        try {
-            publicKey32 = Ed25519Util.keyFromBase64(fromUser.getClientKey());
-        } catch (Exception e) {
-            return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED, "BAD_DEVICE_KEY", "Некорректный clientKey отправителя");
-        }
-        if (!Ed25519Util.verify(packet.signedBody, packet.signature64, publicKey32)) {
-            return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED, "BAD_SIGNATURE", "Подпись не прошла проверку");
-        }
-
-        long now = System.currentTimeMillis();
-        if (Math.abs(now - packet.timeMs) > REPLAY_TTL_MS) {
-            return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED, "BAD_TIME_WINDOW", "Время сообщения вышло за окно 15 минут");
-        }
-
-        boolean replayOk = SignedDmReplayDAO.getInstance().registerUnique(packet.fromLogin, packet.timeMs, packet.nonce, now);
-        if (!replayOk) {
-            return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED, "REPLAY", "Повторное сообщение заблокировано");
-        }
-
-        String messageId = NetIdGenerator.eventId("msg");
-        String textForUi = new String(packet.messageBytes, StandardCharsets.UTF_8);
-
-        DirectMessageEntry entry = new DirectMessageEntry();
-        entry.setMessageId(messageId);
-        entry.setFromLogin(packet.fromLogin);
-        entry.setToLogin(packet.toLogin);
-        entry.setText(textForUi);
-        entry.setCreatedAtMs(now);
-        DirectMessagesDAO.getInstance().insert(entry);
-
-        SignedDirectMessageHistoryEntry history = new SignedDirectMessageHistoryEntry();
-        history.setMessageId(messageId);
-        history.setFromLogin(packet.fromLogin);
-        history.setToLogin(packet.toLogin);
-        history.setTargetMode(packet.targetMode);
-        history.setTargetSessionId(packet.targetSessionId);
-        history.setMessageType(packet.messageType);
-        history.setTimeMs(packet.timeMs);
-        history.setNonce(packet.nonce);
-        history.setRawPacket(packet.rawPacket);
-        history.setCreatedAtMs(now);
-        SignedDirectMessagesHistoryDAO.getInstance().insert(history);
-
-        DeliveryResult delivery = deliver(packet, req.getBlobB64().trim(), messageId, now);
-
-        Net_SendDirectMessage_Response resp = new Net_SendDirectMessage_Response();
-        resp.setOp(req.getOp());
-        resp.setRequestId(req.getRequestId());
-        resp.setStatus(WireCodes.Status.OK);
-        resp.setMessageId(messageId);
-        resp.setDeliveredWsSessions(delivery.wsDelivered);
-        resp.setDeliveredWebPushSessions(delivery.webPushDelivered);
-        resp.setSessionNotFound(delivery.sessionNotFound);
-        return resp;
-    }
-
-    private DeliveryResult deliver(SignedDirectMessagePacket packet, String blobB64, String messageId, long createdAtMs) throws Exception {
-        DeliveryResult result = new DeliveryResult();
-
-        Set<String> selectedSessionIds = new HashSet<>();
-        if (packet.targetMode == SignedDirectMessagePacket.TARGET_ONE_SESSION) {
-            ActiveSessionEntry byId = ActiveSessionsDAO.getInstance().getBySessionId(packet.targetSessionId);
-            if (byId == null || !packet.toLogin.equalsIgnoreCase(byId.getLogin())) {
-                result.sessionNotFound = true;
-                return result;
-            }
-            selectedSessionIds.add(byId.getSessionId());
-            deliverToSession(packet, blobB64, messageId, createdAtMs, byId.getSessionId(), result);
-            return result;
-        }
-
-        List<ActiveSessionEntry> sessions = ActiveSessionsDAO.getInstance().getByLogin(packet.toLogin);
-        for (ActiveSessionEntry s : sessions) {
-            selectedSessionIds.add(s.getSessionId());
-            deliverToSession(packet, blobB64, messageId, createdAtMs, s.getSessionId(), result);
-        }
-        return result;
-    }
-
-    private void deliverToSession(
-            SignedDirectMessagePacket packet,
-            String blobB64,
-            String messageId,
-            long createdAtMs,
-            String sessionId,
-            DeliveryResult result
-    ) {
-        ConnectionContext targetCtx = ActiveConnectionsRegistry.getInstance().getBySessionId(sessionId);
-        boolean wsDelivered = false;
-        if (targetCtx != null) {
-            String eventId = NetIdGenerator.eventId("evt");
-            CompletableFuture<Boolean> waiter = DeliveryTracker.getInstance().register(eventId);
-            ObjectNode payload = MAPPER.createObjectNode();
-            payload.put("eventId", eventId);
-            payload.put("messageId", messageId);
-            payload.put("fromLogin", packet.fromLogin);
-            payload.put("toLogin", packet.toLogin);
-            payload.put("blobB64", blobB64);
-            payload.put("text", new String(packet.messageBytes, StandardCharsets.UTF_8));
-            payload.put("timeMs", createdAtMs);
-
-            boolean sent = WsEventSender.sendEvent(targetCtx, "IncomingDirectMessage", eventId, payload);
-            if (sent) {
-                try {
-                    wsDelivered = waiter.get(1200, TimeUnit.MILLISECONDS);
-                } catch (Exception ignored) {
-                    wsDelivered = false;
-                }
-            }
-            DeliveryTracker.getInstance().remove(eventId);
-        }
-
-        if (wsDelivered) {
-            result.wsDelivered++;
-            return;
-        }
-
-        try {
-            ActiveSessionEntry targetSession = ActiveSessionsDAO.getInstance().getBySessionId(sessionId);
-            if (targetSession == null) return;
-            if (isBlank(targetSession.getPushEndpoint()) || isBlank(targetSession.getPushP256dhKey()) || isBlank(targetSession.getPushAuthKey())) {
-                return;
-            }
-            boolean pushed = WebPushSender.sendBase64Payload(
-                    targetSession.getPushEndpoint(),
-                    targetSession.getPushP256dhKey(),
-                    targetSession.getPushAuthKey(),
-                    blobB64
-            );
-            if (pushed) result.webPushDelivered++;
-        } catch (Exception ignored) {
-            // ignore per-session push errors
-        }
-    }
-
-    private boolean isBlank(String s) {
-        return s == null || s.isBlank();
-    }
-
-    private static final class DeliveryResult {
-        int wsDelivered;
-        int webPushDelivered;
-        boolean sessionNotFound;
-    }
-}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_UserSettingsSyncBatch_Handler.java

@@ -0,0 +1,129 @@
+package server.logic.ws_protocol.JSON.messages;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.JSON.ConnectionContext;
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
+import server.logic.ws_protocol.JSON.messages.entyties.Net_UserSettingsSyncBatch_Request;
+import server.logic.ws_protocol.JSON.messages.entyties.Net_UserSettingsSyncBatch_Response;
+import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.DbController;
+import shine.db.dao.UserAccessServersCurrentDAO;
+import shine.db.dao.UserSettingsDAO;
+import shine.db.entities.UserSettingEntry;
+import shine.db.entities.UserAccessServerRouteEntry;
+import utils.config.AppConfig;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+
+public class Net_UserSettingsSyncBatch_Handler implements JsonMessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(Net_UserSettingsSyncBatch_Handler.class);
+    private static final int DEFAULT_LIMIT = 500;
+    private static final int MAX_LIMIT = 1000;
+    private static final int DEFAULT_MAX_BYTES = 3_000_000;
+    private static final int MAX_BYTES_CAP = 5_000_000;
+    private static final String SERVER_LOGIN_CONFIG = "server.SHiNE.login";
+
+    @Override
+    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) throws Exception {
+        Net_UserSettingsSyncBatch_Request req = (Net_UserSettingsSyncBatch_Request) baseRequest;
+        String ownerLogin = normalizeOriginal(req.getOwnerLogin());
+        if (ownerLogin == null) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "EMPTY_OWNER_LOGIN", "ownerLogin обязателен");
+        }
+
+        String ownServerLogin = normalize(AppConfig.getInstance().getParam(SERVER_LOGIN_CONFIG));
+        if (ownServerLogin == null) {
+            return NetExceptionResponseFactory.error(req, 500, "LOCAL_SERVER_NOT_CONFIGURED", "server.SHiNE.login не настроен");
+        }
+        if (!isLocalAccessServer(ownerLogin, ownServerLogin)) {
+            return NetExceptionResponseFactory.error(req, 403, "LOCAL_SERVER_NOT_ACCESS_SERVER", "Локальный сервер не является access-сервером пользователя");
+        }
+
+        int limit = clamp(req.getLimit() == null ? DEFAULT_LIMIT : req.getLimit(), 1, MAX_LIMIT);
+        int maxBytes = clamp(req.getMaxBytes() == null ? DEFAULT_MAX_BYTES : req.getMaxBytes(), 64_000, MAX_BYTES_CAP);
+        long afterTimeMs = Math.max(0L, req.getAfterTimeMs() == null ? 0L : req.getAfterTimeMs());
+        String afterSettingKey = req.getAfterSettingKey() == null ? "" : req.getAfterSettingKey().trim();
+
+        List<UserSettingEntry> batch;
+        try (Connection c = DbController.getInstance().getConnection()) {
+            batch = UserSettingsDAO.getInstance().listNewerThan(
+                    c,
+                    ownerLogin,
+                    afterTimeMs,
+                    afterSettingKey,
+                    limit
+            );
+        }
+
+        Net_UserSettingsSyncBatch_Response resp = new Net_UserSettingsSyncBatch_Response();
+        resp.setOp(req.getOp());
+        resp.setRequestId(req.getRequestId());
+        resp.setStatus(WireCodes.Status.OK);
+        resp.setOwnerLogin(ownerLogin);
+        resp.setLimit(limit);
+
+        int rawBytes = 0;
+        List<Net_UserSettingsSyncBatch_Response.Item> items = new ArrayList<>();
+        for (UserSettingEntry entry : batch) {
+            Net_UserSettingsSyncBatch_Response.Item item = new Net_UserSettingsSyncBatch_Response.Item();
+            item.setLogin(entry.getLogin());
+            item.setSetting_type(entry.getSettingType());
+            item.setSetting_key(entry.getSettingKey());
+            item.setTime_ms(entry.getTimeMs());
+            item.setValue_text(entry.getValueText());
+            item.setValue_num(entry.getValueNum());
+            item.setClient_key(entry.getClientKey());
+            item.setSignature(entry.getSignature());
+            item.setSynced(entry.isSynced());
+            items.add(item);
+            rawBytes += String.valueOf(entry.getLogin()).length()
+                    + String.valueOf(entry.getSettingKey()).length()
+                    + String.valueOf(entry.getValueText()).length()
+                    + String.valueOf(entry.getClientKey() == null ? "" : entry.getClientKey()).length()
+                    + String.valueOf(entry.getSignature() == null ? "" : entry.getSignature()).length()
+                    + 64;
+            if (rawBytes > maxBytes) break;
+            resp.setNextTimeMs(entry.getTimeMs());
+            resp.setNextSettingKey(entry.getSettingKey());
+        }
+        resp.setRawBytes(rawBytes);
+        resp.setHasMore(batch.size() > items.size());
+        resp.setItems(items);
+        return resp;
+    }
+
+    private boolean isLocalAccessServer(String ownerLogin, String ownServerLogin) throws Exception {
+        try (Connection c = DbController.getInstance().getConnection()) {
+            for (UserAccessServerRouteEntry route : UserAccessServersCurrentDAO.getInstance().listByUserLogin(c, ownerLogin)) {
+                if (route == null || route.getServerLogin() == null) continue;
+                if (ownServerLogin.equals(normalize(route.getServerLogin()))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private static int clamp(int value, int min, int max) {
+        return Math.max(min, Math.min(max, value));
+    }
+
+    private static String normalize(String value) {
+        if (value == null) return null;
+        String s = value.trim().toLowerCase();
+        return s.isEmpty() ? null : s;
+    }
+
+    private static String normalizeOriginal(String value) {
+        if (value == null) return null;
+        String s = value.trim();
+        return s.isEmpty() ? null : s;
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/UserSettingsSyncApplySupport.java

@@ -0,0 +1,61 @@
+package server.logic.ws_protocol.JSON.messages;
+
+import server.logic.ws_protocol.JSON.messages.entyties.Net_UserSettingsSyncBatch_Response;
+import shine.db.dao.UserSettingsDAO;
+import shine.db.entities.UserSettingEntry;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class UserSettingsSyncApplySupport {
+    private UserSettingsSyncApplySupport() {}
+
+    public static ApplyResult applySyncedItem(Connection c, String ownerLogin, Net_UserSettingsSyncBatch_Response.Item item) throws Exception {
+        if (item == null) return new ApplyResult(false, "empty_item");
+        String login = normalize(item.getLogin());
+        String key = normalize(item.getSetting_key());
+        if (login == null || key == null) return new ApplyResult(false, "bad_item");
+
+        UserSettingEntry entry = new UserSettingEntry(
+                login,
+                item.getSetting_type() == null ? 0 : item.getSetting_type(),
+                key,
+                item.getTime_ms() == null ? 0L : item.getTime_ms(),
+                item.getValue_text() == null ? "" : item.getValue_text(),
+                item.getValue_num() == null ? 0L : item.getValue_num(),
+                item.getClient_key(),
+                item.getSignature(),
+                true
+        );
+        int changed = UserSettingsDAO.getInstance().upsertIfNewer(c, entry);
+        return new ApplyResult(changed > 0, changed > 0 ? "applied" : "ignored");
+    }
+
+    public static List<UserSettingEntry> toEntries(List<Net_UserSettingsSyncBatch_Response.Item> items) {
+        List<UserSettingEntry> out = new ArrayList<>();
+        if (items == null) return out;
+        for (Net_UserSettingsSyncBatch_Response.Item item : items) {
+            if (item == null) continue;
+            out.add(new UserSettingEntry(
+                    normalize(item.getLogin()),
+                    item.getSetting_type() == null ? 0 : item.getSetting_type(),
+                    normalize(item.getSetting_key()),
+                    item.getTime_ms() == null ? 0L : item.getTime_ms(),
+                    item.getValue_text() == null ? "" : item.getValue_text(),
+                    item.getValue_num() == null ? 0L : item.getValue_num(),
+                    item.getClient_key(),
+                    item.getSignature(),
+                    true
+            ));
+        }
+        return out;
+    }
+
+    private static String normalize(String value) {
+        String s = String.valueOf(value == null ? "" : value).trim();
+        return s.isEmpty() ? null : s;
+    }
+
+    public record ApplyResult(boolean applied, String status) {}
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_MarkAllUserSettingsUnsynced_Request.java

@@ -0,0 +1,10 @@
+package server.logic.ws_protocol.JSON.messages.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+
+public class Net_MarkAllUserSettingsUnsynced_Request extends Net_Request {
+    private String login;
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_MarkAllUserSettingsUnsynced_Response.java

@@ -0,0 +1,10 @@
+package server.logic.ws_protocol.JSON.messages.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+
+public class Net_MarkAllUserSettingsUnsynced_Response extends Net_Response {
+    private Integer updated;
+
+    public Integer getUpdated() { return updated; }
+    public void setUpdated(Integer updated) { this.updated = updated; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_SendDirectMessage_Request.java

@@ -1,10 +0,0 @@
-package server.logic.ws_protocol.JSON.messages.entyties;
-
-import server.logic.ws_protocol.JSON.entyties.Net_Request;
-
-public class Net_SendDirectMessage_Request extends Net_Request {
-    private String blobB64;
-
-    public String getBlobB64() { return blobB64; }
-    public void setBlobB64(String blobB64) { this.blobB64 = blobB64; }
-}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_SendDirectMessage_Response.java

@@ -1,19 +0,0 @@
-package server.logic.ws_protocol.JSON.messages.entyties;
-
-import server.logic.ws_protocol.JSON.entyties.Net_Response;
-
-public class Net_SendDirectMessage_Response extends Net_Response {
-    private String messageId;
-    private int deliveredWsSessions;
-    private int deliveredWebPushSessions;
-    private boolean sessionNotFound;
-
-    public String getMessageId() { return messageId; }
-    public void setMessageId(String messageId) { this.messageId = messageId; }
-    public int getDeliveredWsSessions() { return deliveredWsSessions; }
-    public void setDeliveredWsSessions(int deliveredWsSessions) { this.deliveredWsSessions = deliveredWsSessions; }
-    public int getDeliveredWebPushSessions() { return deliveredWebPushSessions; }
-    public void setDeliveredWebPushSessions(int deliveredWebPushSessions) { this.deliveredWebPushSessions = deliveredWebPushSessions; }
-    public boolean isSessionNotFound() { return sessionNotFound; }
-    public void setSessionNotFound(boolean sessionNotFound) { this.sessionNotFound = sessionNotFound; }
-}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_UserSettingsSyncBatch_Request.java

@@ -0,0 +1,26 @@
+package server.logic.ws_protocol.JSON.messages.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+
+public class Net_UserSettingsSyncBatch_Request extends Net_Request {
+    private String ownerLogin;
+    private Long afterTimeMs;
+    private String afterSettingKey;
+    private Integer limit;
+    private Integer maxBytes;
+
+    public String getOwnerLogin() { return ownerLogin; }
+    public void setOwnerLogin(String ownerLogin) { this.ownerLogin = ownerLogin; }
+
+    public Long getAfterTimeMs() { return afterTimeMs; }
+    public void setAfterTimeMs(Long afterTimeMs) { this.afterTimeMs = afterTimeMs; }
+
+    public String getAfterSettingKey() { return afterSettingKey; }
+    public void setAfterSettingKey(String afterSettingKey) { this.afterSettingKey = afterSettingKey; }
+
+    public Integer getLimit() { return limit; }
+    public void setLimit(Integer limit) { this.limit = limit; }
+
+    public Integer getMaxBytes() { return maxBytes; }
+    public void setMaxBytes(Integer maxBytes) { this.maxBytes = maxBytes; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_UserSettingsSyncBatch_Response.java

@@ -0,0 +1,62 @@
+package server.logic.ws_protocol.JSON.messages.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Net_UserSettingsSyncBatch_Response extends Net_Response {
+    private String ownerLogin;
+    private Integer limit;
+    private Integer rawBytes;
+    private Boolean hasMore;
+    private Long nextTimeMs;
+    private String nextSettingKey;
+    private List<Item> items = new ArrayList<>();
+
+    public String getOwnerLogin() { return ownerLogin; }
+    public void setOwnerLogin(String ownerLogin) { this.ownerLogin = ownerLogin; }
+    public Integer getLimit() { return limit; }
+    public void setLimit(Integer limit) { this.limit = limit; }
+    public Integer getRawBytes() { return rawBytes; }
+    public void setRawBytes(Integer rawBytes) { this.rawBytes = rawBytes; }
+    public Boolean getHasMore() { return hasMore; }
+    public void setHasMore(Boolean hasMore) { this.hasMore = hasMore; }
+    public Long getNextTimeMs() { return nextTimeMs; }
+    public void setNextTimeMs(Long nextTimeMs) { this.nextTimeMs = nextTimeMs; }
+    public String getNextSettingKey() { return nextSettingKey; }
+    public void setNextSettingKey(String nextSettingKey) { this.nextSettingKey = nextSettingKey; }
+    public List<Item> getItems() { return items; }
+    public void setItems(List<Item> items) { this.items = items; }
+
+    public static class Item {
+        private String login;
+        private Integer setting_type;
+        private String setting_key;
+        private Long time_ms;
+        private String value_text;
+        private Long value_num;
+        private String client_key;
+        private String signature;
+        private Boolean synced;
+
+        public String getLogin() { return login; }
+        public void setLogin(String login) { this.login = login; }
+        public Integer getSetting_type() { return setting_type; }
+        public void setSetting_type(Integer setting_type) { this.setting_type = setting_type; }
+        public String getSetting_key() { return setting_key; }
+        public void setSetting_key(String setting_key) { this.setting_key = setting_key; }
+        public Long getTime_ms() { return time_ms; }
+        public void setTime_ms(Long time_ms) { this.time_ms = time_ms; }
+        public String getValue_text() { return value_text; }
+        public void setValue_text(String value_text) { this.value_text = value_text; }
+        public Long getValue_num() { return value_num; }
+        public void setValue_num(Long value_num) { this.value_num = value_num; }
+        public String getClient_key() { return client_key; }
+        public void setClient_key(String client_key) { this.client_key = client_key; }
+        public String getSignature() { return signature; }
+        public void setSignature(String signature) { this.signature = signature; }
+        public Boolean getSynced() { return synced; }
+        public void setSynced(Boolean synced) { this.synced = synced; }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/RemoteUserSettingsSyncClient.java

@@ -0,0 +1,209 @@
+package server.sync;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import shine.db.entities.UserSettingEntry;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.WebSocket;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public final class RemoteUserSettingsSyncClient {
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final HttpClient HTTP = HttpClient.newBuilder()
+            .connectTimeout(Duration.ofSeconds(6))
+            .build();
+
+    public void upsertUserSetting(String serverAddressRaw, UserSettingEntry entry, boolean syncDelivery) throws Exception {
+        JsonNode response = send(serverAddressRaw, """
+            {
+              "op":"UpsertUserSetting",
+              "requestId":%s,
+              "payload":{
+                "login":%s,
+                "setting_type":%d,
+                "setting_key":%s,
+                "time_ms":%d,
+                "value_text":%s,
+                "value_num":%d,
+                "client_key":%s,
+                "signature":%s,
+                "sync_delivery":%s
+              }
+            }
+            """.formatted(
+                "%s",
+                MAPPER.writeValueAsString(entry.getLogin()),
+                entry.getSettingType(),
+                MAPPER.writeValueAsString(entry.getSettingKey()),
+                entry.getTimeMs(),
+                MAPPER.writeValueAsString(entry.getValueText() == null ? "" : entry.getValueText()),
+                entry.getValueNum(),
+                MAPPER.writeValueAsString(entry.getClientKey() == null ? "" : entry.getClientKey()),
+                MAPPER.writeValueAsString(entry.getSignature() == null ? "" : entry.getSignature()),
+                syncDelivery ? "true" : "false"
+            ));
+        ensureOk("UpsertUserSetting", response);
+    }
+
+    public RemoteUserSettingsBatch userSettingsSyncBatch(
+            String serverAddressRaw,
+            String ownerLogin,
+            long afterTimeMs,
+            String afterSettingKey,
+            int limit,
+            int maxBytes
+    ) throws Exception {
+        JsonNode response = send(serverAddressRaw, """
+            {
+              "op":"UserSettingsSyncBatch",
+              "requestId":%s,
+              "payload":{
+                "ownerLogin":%s,
+                "afterTimeMs":%d,
+                "afterSettingKey":%s,
+                "limit":%d,
+                "maxBytes":%d
+              }
+            }
+            """.formatted(
+                "%s",
+                MAPPER.writeValueAsString(ownerLogin),
+                Math.max(0L, afterTimeMs),
+                MAPPER.writeValueAsString(afterSettingKey == null ? "" : afterSettingKey),
+                limit,
+                maxBytes
+            ));
+        ensureOk("UserSettingsSyncBatch", response);
+
+        JsonNode payload = response.path("payload");
+        List<RemoteUserSettingsItem> items = new ArrayList<>();
+        JsonNode arr = payload.path("items");
+        if (arr.isArray()) {
+            for (JsonNode item : arr) {
+                items.add(new RemoteUserSettingsItem(
+                        item.path("login").asText(""),
+                        item.path("setting_type").asInt(0),
+                        item.path("setting_key").asText(""),
+                        item.path("time_ms").asLong(0L),
+                        item.path("value_text").asText(""),
+                        item.path("value_num").asLong(0L),
+                        item.path("client_key").asText(""),
+                        item.path("signature").asText("")
+                ));
+            }
+        }
+        return new RemoteUserSettingsBatch(
+                payload.path("nextTimeMs").asLong(afterTimeMs),
+                payload.path("nextSettingKey").asText(afterSettingKey == null ? "" : afterSettingKey),
+                payload.path("hasMore").asBoolean(false),
+                items
+        );
+    }
+
+    private JsonNode send(String serverAddressRaw, String jsonTemplate) throws Exception {
+        String requestId = MAPPER.writeValueAsString("user-settings-sync-" + UUID.randomUUID());
+        String json = jsonTemplate.formatted(requestId);
+        String wsUrl = RemoteBlockchainSyncClient.buildWsUrl(serverAddressRaw);
+        if (wsUrl == null) {
+            throw new IllegalArgumentException("Invalid server address: " + serverAddressRaw);
+        }
+
+        CompletableFuture<String> responseFuture = new CompletableFuture<>();
+        CountDownLatch openLatch = new CountDownLatch(1);
+        SyncWsListener listener = new SyncWsListener(responseFuture, openLatch);
+
+        WebSocket webSocket = HTTP.newWebSocketBuilder()
+                .connectTimeout(Duration.ofSeconds(6))
+                .buildAsync(URI.create(wsUrl), listener)
+                .get(8, TimeUnit.SECONDS);
+
+        if (!openLatch.await(8, TimeUnit.SECONDS)) {
+            tryAbort(webSocket);
+            throw new TimeoutException("WS open timeout");
+        }
+
+        webSocket.sendText(json, true).get(8, TimeUnit.SECONDS);
+        String responseJson = responseFuture.get(12, TimeUnit.SECONDS);
+        tryAbort(webSocket);
+        return MAPPER.readTree(responseJson);
+    }
+
+    private void ensureOk(String op, JsonNode response) {
+        int status = response.path("status").asInt(500);
+        if (status >= 200 && status < 300) return;
+        String code = response.path("code").asText("");
+        if (code.isBlank()) code = response.path("error").asText("");
+        throw new IllegalStateException(op + " failed: status=" + status + " code=" + code);
+    }
+
+    private static void tryAbort(WebSocket webSocket) {
+        try {
+            webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "ok");
+        } catch (Exception ignored) {
+        }
+        try {
+            webSocket.abort();
+        } catch (Exception ignored) {
+        }
+    }
+
+    public record RemoteUserSettingsBatch(
+            long nextTimeMs,
+            String nextSettingKey,
+            boolean hasMore,
+            List<RemoteUserSettingsItem> items
+    ) {}
+
+    public record RemoteUserSettingsItem(
+            String login,
+            int settingType,
+            String settingKey,
+            long timeMs,
+            String valueText,
+            long valueNum,
+            String clientKey,
+            String signature
+    ) {}
+
+    private static final class SyncWsListener implements WebSocket.Listener {
+        private final CompletableFuture<String> responseFuture;
+        private final CountDownLatch openLatch;
+        private final StringBuilder textBuffer = new StringBuilder();
+
+        private SyncWsListener(CompletableFuture<String> responseFuture, CountDownLatch openLatch) {
+            this.responseFuture = responseFuture;
+            this.openLatch = openLatch;
+        }
+
+        @Override
+        public void onOpen(WebSocket webSocket) {
+            openLatch.countDown();
+            webSocket.request(1);
+        }
+
+        @Override
+        public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
+            textBuffer.append(data);
+            if (last && !responseFuture.isDone()) {
+                responseFuture.complete(textBuffer.toString());
+            }
+            webSocket.request(1);
+            return CompletableFuture.completedFuture(null);
+        }
+
+        @Override
+        public void onError(WebSocket webSocket, Throwable error) {
+            responseFuture.completeExceptionally(error);
+        }
+    }
+}

SHiNE-server/src/main/java/server/sync/PeriodicUserSettingsSyncService.java

@@ -0,0 +1,206 @@
+package server.sync;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import shine.db.dao.UserAccessServersCurrentDAO;
+import shine.db.dao.UserSettingsDAO;
+import shine.db.dao.UserSettingsSyncPeerStateDAO;
+import shine.db.entities.UserAccessServerRouteEntry;
+import shine.db.entities.UserSettingEntry;
+import shine.db.entities.UserSettingsSyncPeerStateEntry;
+import utils.config.AppConfig;
+
+import java.sql.Connection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public final class PeriodicUserSettingsSyncService {
+    private static final Logger log = LoggerFactory.getLogger(PeriodicUserSettingsSyncService.class);
+    private static final String SERVER_LOGIN_CONFIG = "server.SHiNE.login";
+    private static final AtomicBoolean STARTED = new AtomicBoolean(false);
+    private static final RemoteUserSettingsSyncClient REMOTE = new RemoteUserSettingsSyncClient();
+    private static final UserAccessServersCurrentDAO ACCESS_DAO = UserAccessServersCurrentDAO.getInstance();
+    private static final UserSettingsDAO SETTINGS_DAO = UserSettingsDAO.getInstance();
+    private static final UserSettingsSyncPeerStateDAO STATE_DAO = UserSettingsSyncPeerStateDAO.getInstance();
+
+    private static final ScheduledExecutorService EXECUTOR = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
+        @Override
+        public Thread newThread(Runnable r) {
+            Thread t = new Thread(r, "periodic-user-settings-sync");
+            t.setDaemon(true);
+            return t;
+        }
+    });
+
+    private PeriodicUserSettingsSyncService() {}
+
+    public static void startOrLog() {
+        if (!isEnabled()) {
+            log.info("Periodic user settings sync disabled by user.settings.sync.enabled=false");
+            return;
+        }
+        if (!STARTED.compareAndSet(false, true)) return;
+        long initialDelaySec = configLong("user.settings.sync.initialDelaySeconds", 90L, 0L, 3600L);
+        long periodHours = configLong("user.settings.sync.periodHours", 6L, 1L, 168L);
+        EXECUTOR.scheduleWithFixedDelay(
+                PeriodicUserSettingsSyncService::runCycleSafe,
+                initialDelaySec,
+                TimeUnit.HOURS.toSeconds(periodHours),
+                TimeUnit.SECONDS
+        );
+        log.info("Periodic user settings sync scheduled: first run in {} seconds, then every {} hours", initialDelaySec, periodHours);
+    }
+
+    private static void runCycleSafe() {
+        try {
+            runCycle();
+        } catch (Exception e) {
+            log.error("Periodic user settings sync failed unexpectedly", e);
+        }
+    }
+
+    private static void runCycle() throws Exception {
+        String ownServerLogin = normalize(AppConfig.getInstance().getParam(SERVER_LOGIN_CONFIG));
+        if (ownServerLogin == null) {
+            log.warn("Periodic user settings sync skipped: {} is empty", SERVER_LOGIN_CONFIG);
+            return;
+        }
+
+        List<String> ownersRaw = ACCESS_DAO.listUserLoginsByServerLogin(ownServerLogin);
+        Set<String> owners = new LinkedHashSet<>(ownersRaw);
+        if (owners.isEmpty()) {
+            log.info("Periodic user settings sync skipped: no local access-server users for {}", ownServerLogin);
+            return;
+        }
+
+        int syncedPeers = 0;
+        int appliedItems = 0;
+        int pushedItems = 0;
+        for (String ownerLogin : owners) {
+            List<UserAccessServerRouteEntry> routes = ACCESS_DAO.listByUserLogin(ownerLogin);
+            for (UserAccessServerRouteEntry route : routes) {
+                if (route == null) continue;
+                String remoteLogin = normalize(route.getServerLogin());
+                String remoteUrl = route.getServerUrl();
+                if (remoteLogin == null || remoteUrl == null || remoteUrl.isBlank()) continue;
+                if (remoteLogin.equals(ownServerLogin)) continue;
+
+                try {
+                    SyncStats stats = syncOwnerWithRemote(ownerLogin, route);
+                    appliedItems += stats.applied();
+                    pushedItems += stats.pushed();
+                    syncedPeers++;
+                } catch (Exception e) {
+                    STATE_DAO.updateError(ownerLogin, route.getServerLogin(), remoteUrl, String.valueOf(e));
+                    log.warn("Periodic user settings sync peer failed: owner={} remoteServer={} reason={}",
+                            ownerLogin, route.getServerLogin(), String.valueOf(e));
+                }
+            }
+        }
+
+        log.info("Periodic user settings sync cycle finished: owners={} syncedPeers={} appliedItems={} pushedItems={}",
+                owners.size(), syncedPeers, appliedItems, pushedItems);
+    }
+
+    private static SyncStats syncOwnerWithRemote(String ownerLogin, UserAccessServerRouteEntry route) throws Exception {
+        int limit = (int) configLong("user.settings.sync.batchLimit", 500L, 1L, 1000L);
+        int maxBytes = (int) configLong("user.settings.sync.batchMaxBytes", 3_000_000L, 64_000L, 5_000_000L);
+        int maxPages = (int) configLong("user.settings.sync.maxPagesPerPeer", 50L, 1L, 500L);
+
+        UserSettingsSyncPeerStateEntry state;
+        try (Connection c = getDbConnection()) {
+            state = STATE_DAO.getOrCreate(c, ownerLogin, route.getServerLogin(), route.getServerUrl());
+        }
+        long cursorTimeMs = state.getCursorTimeMs();
+        String cursorSettingKey = state.getCursorSettingKey() == null ? "" : state.getCursorSettingKey();
+        int applied = 0;
+        int pushed = 0;
+        boolean bootstrapCompleted = false;
+
+        for (int page = 0; page < maxPages; page++) {
+            RemoteUserSettingsSyncClient.RemoteUserSettingsBatch batch = REMOTE.userSettingsSyncBatch(
+                    route.getServerUrl(),
+                    ownerLogin,
+                    cursorTimeMs,
+                    cursorSettingKey,
+                    limit,
+                    maxBytes
+            );
+
+            try (Connection c = getDbConnection()) {
+                for (RemoteUserSettingsSyncClient.RemoteUserSettingsItem item : batch.items()) {
+                    UserSettingEntry entry = new UserSettingEntry(
+                            item.login(),
+                            item.settingType(),
+                            item.settingKey(),
+                            item.timeMs(),
+                            item.valueText(),
+                            item.valueNum(),
+                            item.clientKey(),
+                            item.signature(),
+                            true
+                    );
+                    int changed = SETTINGS_DAO.upsertIfNewer(c, entry);
+                    if (changed > 0) applied++;
+                }
+            }
+
+            cursorTimeMs = Math.max(cursorTimeMs, batch.nextTimeMs());
+            cursorSettingKey = batch.nextSettingKey() == null ? "" : batch.nextSettingKey();
+            bootstrapCompleted = !batch.hasMore();
+            STATE_DAO.updateSuccess(ownerLogin, route.getServerLogin(), route.getServerUrl(), cursorTimeMs, cursorSettingKey, bootstrapCompleted);
+
+            if (!batch.hasMore() || batch.items().isEmpty()) break;
+        }
+
+        try (Connection c = getDbConnection()) {
+            List<UserSettingEntry> unsynced = SETTINGS_DAO.listUnsyncedByLogin(c, ownerLogin, limit);
+            for (UserSettingEntry entry : unsynced) {
+                REMOTE.upsertUserSetting(route.getServerUrl(), entry, true);
+                SETTINGS_DAO.markSynced(c, entry.getLogin(), entry.getSettingType(), entry.getSettingKey());
+                pushed++;
+            }
+        }
+
+        if (!bootstrapCompleted) {
+            log.info("Periodic user settings sync peer paused by page limit: owner={} remoteServer={} maxPages={}",
+                    ownerLogin, route.getServerLogin(), maxPages);
+        }
+        return new SyncStats(applied, pushed);
+    }
+
+    private static java.sql.Connection getDbConnection() throws Exception {
+        return shine.db.DbController.getInstance().getConnection();
+    }
+
+    private static boolean isEnabled() {
+        String raw = AppConfig.getInstance().getParam("user.settings.sync.enabled");
+        return raw == null || raw.isBlank() || Boolean.parseBoolean(raw.trim());
+    }
+
+    private static long configLong(String key, long defaultValue, long min, long max) {
+        String raw = AppConfig.getInstance().getParam(key);
+        if (raw == null || raw.isBlank()) return defaultValue;
+        try {
+            long parsed = Long.parseLong(raw.trim());
+            return Math.max(min, Math.min(max, parsed));
+        } catch (Exception ignored) {
+            return defaultValue;
+        }
+    }
+
+    private static String normalize(String value) {
+        if (value == null) return null;
+        String s = value.trim().toLowerCase(Locale.ROOT);
+        return s.isEmpty() ? null : s;
+    }
+
+    private record SyncStats(int applied, int pushed) {}
+}

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

@@ -9,6 +9,7 @@ import server.debug.DebugApiConfigurator;
 import server.sync.BlockchainResyncRecoveryOnStartup;
 import server.sync.PeriodicBlockchainSyncService;
 import server.sync.PeriodicDmSyncService;
+import server.sync.PeriodicUserSettingsSyncService;
 import server.sync.SolanaUsersSyncStartupService;
 import server.sync.SyncServersBootstrapService;
 import utils.config.AppConfig;
@@ -104,6 +105,7 @@ public final class WsServer {
         server.start();
         log.info("✅ WS сервер запущен на ws://localhost:{}/ws", port);
         PeriodicDmSyncService.startOrLog();
+        PeriodicUserSettingsSyncService.startOrLog();
         server.join();
     }
 }

SHiNE-server/src/test/java/test/it/cases/IT_03_AddBlock_NoAuth.java

@@ -189,11 +189,11 @@ public class IT_03_AddBlock_NoAuth {
                     "U2 follows U1 channel 'News' (target=U1 CREATE_CHANNEL root)", t);
 
             // 3) FRIEND взаимно (на HEADER)
-            sendConnection(sender1, st1, MsgSubType.CONNECTION_FRIEND,
+            sendConnection(sender1, st1, MsgSubType.CONNECTION_CLOSE_FRIEND,
                     bch2, u2HeaderBlock, u2HeaderHash,
                     "U1 -> U2: FRIEND", t);
 
-            sendConnection(sender2, st2, MsgSubType.CONNECTION_FRIEND,
+            sendConnection(sender2, st2, MsgSubType.CONNECTION_CLOSE_FRIEND,
                     bch1, u1HeaderBlock, u1HeaderHash,
                     "U2 -> U1: FRIEND", t);
 

TODO/Arweave/notifications_projection_full_resync.md

@@ -0,0 +1,21 @@
+# TODO: уведомления и full-resync после фиксации блоков в Arweave
+
+## Контекст
+
+`user_notifications_state` является производным индексом blockchain-блоков. Сейчас full-resync цепочки очищает и перестраивает основные derived-state таблицы, но уведомления специально не включены в этот cleanup.
+
+На текущем этапе это **не исправляем**, потому что логика синхронизации ещё будет дорабатываться, а надёжность/финальность блоков планируется усилить записью в Arweave.
+
+## Что проверить после внедрения Arweave
+
+Когда схема Arweave и правила восстановления цепочки стабилизируются:
+
+- определить окончательный source of truth для accepted/finalized blocks;
+- проверить поведение `user_notifications_state` при rollback/full-resync;
+- если цепочка может реально заменить ранее принятый блок, удалять/перестраивать уведомления по `source_bch_name` и фактическому набору финальных блоков;
+- не допускать stale-уведомлений от блоков, которые больше не входят в подтверждённую цепочку;
+- добавить интеграционный тест на divergence + full-resync + notification projection.
+
+## Важно
+
+До появления финальной Arweave/recovery-модели не добавлять временную сложную cleanup-логику только ради этого редкого сценария.

VERSION.properties

@@ -1,2 +1,2 @@
 client.version=1.7.0
-server.version=1.6.0
+server.version=1.6.1

bundle.sh

@@ -0,0 +1,173 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# Build a source bundle ZIP while excluding credentials, private keys,
+# local state, generated artifacts and other likely secrets.
+#
+# Usage:
+#   ./bundle.sh
+#   ./bundle.sh path/to/output.zip
+#
+# Run from anywhere inside the project; the script resolves its own directory.
+
+ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+cd "$ROOT"
+
+OUT="${1:-SHiNE-bundle-$(date +%Y%m%d-%H%M%S).zip}"
+case "$OUT" in
+  /*) ;;
+  *) OUT="$ROOT/$OUT" ;;
+esac
+
+if ! command -v zip >/dev/null 2>&1; then
+  echo "ERROR: 'zip' is required." >&2
+  exit 1
+fi
+
+TMP="$(mktemp -d)"
+LIST="$TMP/files.txt"
+SAFE_LIST="$TMP/safe-files.txt"
+trap 'rm -rf "$TMP"' EXIT
+
+# Paths / filenames that must never be bundled.
+is_denied_path() {
+  local p="/$1"
+
+  case "$p" in
+    */.git/*|*/.git|\
+    */.gradle/*|*/.gradle|\
+    */.gradle-home/*|*/.gradle-home|\
+    */.idea/*|*/.idea|\
+    */.vscode/*|*/.vscode|\
+    */node_modules/*|*/node_modules|\
+    */target/*|*/target|\
+    */build/*|*/build|\
+    */out/*|*/out|\
+    */bin/*|*/bin|\
+    */logs/*|*/logs|\
+    */data/*|*/data|\
+    */test-ledger/*|*/test-ledger|\
+    */.anchor/*|*/.anchor|\
+    */.yarn/*|*/.yarn|\
+    */.vendor/*|*/.vendor|\
+    */.agents/*|*/.agents|\
+    */.codex/*|*/.codex|\
+    */.claude/*|*/.claude|\
+    */deploy/backup/archive/*|\
+    */scripts/*/runs/*|\
+    */scripts/*/keypairs/*|\
+    */keys/*|\
+    */.git-local-backup/*)
+      return 0
+      ;;
+  esac
+
+  local base="${p##*/}"
+  local lower
+  lower="$(printf '%s' "$base" | tr '[:upper:]' '[:lower:]')"
+
+  case "$lower" in
+    .env|.env.*|\
+    .debug-token|\
+    .npmrc|.pypirc|.netrc|\
+    credentials|credentials.*|\
+    secrets|secrets.*|\
+    secret|secret.*|\
+    id_rsa|id_dsa|id_ecdsa|id_ed25519|\
+    *.pem|*.key|*.p12|*.pfx|*.jks|*.keystore|\
+    *keypair*.json|\
+    service-account*.json|\
+    firebase-adminsdk*.json|\
+    google-services.json|\
+    validator.log)
+      return 0
+      ;;
+  esac
+
+  case "$lower" in
+    *.class|*.jar|*.war|*.ear|*.o|*.a|*.so|*.dll|*.dylib|\
+    *.elf|*.map|*.uf2|*.bin|*.merged.bin|\
+    *.log|*.bak|*.bak.png|*.tmp|*.swp|*.swo|\
+    .ds_store)
+      return 0
+      ;;
+  esac
+
+  return 1
+}
+
+# Collect files. Prefer Git because it naturally avoids most ignored local files.
+if command -v git >/dev/null 2>&1 && git -C "$ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  git -C "$ROOT" ls-files -co --exclude-standard -z > "$TMP/files.z"
+else
+  find "$ROOT" -type f -print0 > "$TMP/files.z"
+fi
+
+# Convert to project-relative paths and enforce hard deny rules.
+: > "$LIST"
+while IFS= read -r -d '' f; do
+  if [[ "$f" = /* ]]; then
+    rel="${f#"$ROOT"/}"
+  else
+    rel="$f"
+  fi
+
+  [[ "$rel" == "$OUT" ]] && continue
+  [[ -z "$rel" ]] && continue
+
+  if is_denied_path "$rel"; then
+    continue
+  fi
+
+  printf '%s\n' "$rel" >> "$LIST"
+done < "$TMP/files.z"
+
+sort -u "$LIST" -o "$LIST"
+
+# Content scan: fail closed on common credential/private-key patterns.
+# We scan only text-ish files; grep -I skips binary data.
+SECRET_RE='-----BEGIN ([A-Z0-9 ]+ )?PRIVATE KEY-----|AKIA[0-9A-Z]{16}|ASIA[0-9A-Z]{16}|gh[pousr]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]{20,}|sk-[A-Za-z0-9_-]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AIza[0-9A-Za-z_-]{30,}|(^|[^A-Za-z0-9])(password|passwd|pwd|secret|api[_-]?key|access[_-]?token|auth[_-]?token|private[_-]?key)[[:space:]]*[:=][[:space:]]*["'\'']?[^${[:space:]]{][^[:space:]]{7,}'
+
+: > "$SAFE_LIST"
+found_secret=0
+
+while IFS= read -r rel; do
+  [[ -f "$ROOT/$rel" ]] || continue
+
+  # Files that contain examples/templates can legitimately mention secret keys
+  # with placeholders. They are scanned too, but placeholder-looking values
+  # are less likely to match the regex above.
+  if LC_ALL=C grep -IEnq "$SECRET_RE" "$ROOT/$rel" 2>/dev/null; then
+    echo "BLOCKED: possible secret in $rel" >&2
+    LC_ALL=C grep -IEn "$SECRET_RE" "$ROOT/$rel" 2>/dev/null \
+      | sed -E 's/(:[[:space:]]*).*/\1[REDACTED]/' \
+      | head -n 3 >&2 || true
+    found_secret=1
+    continue
+  fi
+
+  printf '%s\n' "$rel" >> "$SAFE_LIST"
+done < "$LIST"
+
+if (( found_secret != 0 )); then
+  echo >&2
+  echo "Bundle NOT created because possible secrets were detected." >&2
+  echo "Move secrets to ignored/local files or adjust the scanner only after review." >&2
+  exit 2
+fi
+
+if [[ ! -s "$SAFE_LIST" ]]; then
+  echo "ERROR: no files left to bundle." >&2
+  exit 3
+fi
+
+rm -f -- "$OUT"
+
+(
+  cd "$ROOT"
+  zip -q -9 "$OUT" -@ < "$SAFE_LIST"
+)
+
+echo "Created: $OUT"
+echo "Files:   $(wc -l < "$SAFE_LIST" | tr -d ' ')"
+echo "Size:    $(du -h "$OUT" | awk '{print $1}')"

docs/API/09_Operations_Index.md

@@ -51,10 +51,14 @@
 | `UpsertUserParam` | `10_User_Params_API.md` | запись параметра пользователя |
 | `GetUserParam` | `10_User_Params_API.md` | чтение одного параметра пользователя |
 | `ListUserParams` | `10_User_Params_API.md` | список параметров пользователя |
+| `UpsertUserSetting` | `13_User_Settings_API.md` | запись пользовательской настройки |
+| `GetUserSetting` | `13_User_Settings_API.md` | чтение одной пользовательской настройки |
+| `ListUserSettings` | `13_User_Settings_API.md` | список пользовательских настроек |
 | `GetFriendsLists` | `11_Connections_API.md` | входящие/исходящие друзья |
 | `ListContacts` | `11_Connections_API.md` | контакты текущего пользователя |
 | `GetUserConnectionsGraph` | `11_Connections_API.md` | граф связей пользователя |
 | `AddCloseFriend` | `11_Connections_API.md` | добавить близкого друга |
+| `GetNotifications` | `15_Notifications_API.md` | ответы и события уведомлений |
 | `UpsertPushToken` | `12_Direct_Messages_Push_Calls_API.md` | регистрация WebPush-токена |
 | `SendTestWebPush` | `12_Direct_Messages_Push_Calls_API.md` | тестовая push-доставка |
 | `SendMessagePair` | `12_Direct_Messages_Push_Calls_API.md` | отправка пары входящий/исходящий DM |
@@ -63,6 +67,8 @@
 | `DeleteMessage` | `12_Direct_Messages_Push_Calls_API.md` | tombstone одного личного сообщения у обеих сторон |
 | `DeleteConversation` | `12_Direct_Messages_Push_Calls_API.md` | tombstone удаления истории переписки |
 | `DmSyncBatch` | `12_Direct_Messages_Push_Calls_API.md` | межсерверная догоняющая синхронизация DM по курсору |
+| `UserSettingsSyncBatch` | `13_User_Settings_API.md` | межсерверная догоняющая синхронизация пользовательских настроек по курсору |
+| `MarkAllUserSettingsUnsynced` | `13_User_Settings_API.md` | служебная пометка всех настроек как несинхронизированных |
 | `GetDirectMessages` | `12_Direct_Messages_Push_Calls_API.md` | постраничная загрузка истории личного диалога |
 | `AckSessionDelivery` | `12_Direct_Messages_Push_Calls_API.md` | подтверждение доставки в сессию |
 | `CallInviteBroadcast` | `12_Direct_Messages_Push_Calls_API.md` | broadcast приглашения к звонку |
@@ -71,7 +77,6 @@
 ## Важные замечания
 
 - `ReceiveOutcomingMessage` сейчас зарегистрирован как алиас того же handler/request-класса, что и `SendMessagePair`.
-- Legacy-операция `SendDirectMessage` больше не зарегистрирована и не должна использоваться для DM v1.
 - Отдельных HTTP endpoints для DM-файлов сейчас нет.
 - Классы `Net_MarkChannelMessagesSeen_*` существуют в коде, но операция `MarkChannelMessagesSeen` не зарегистрирована в `JsonHandlerRegistry`, поэтому в публичный список API не входит.
 - HTTP debug endpoints из `src/main/java/server/debug/` не входят в этот индекс WebSocket `op`; они описаны отдельно в `13_HTTP_Debug_API.md`.

docs/API/12_Direct_Messages_Push_Calls_API.md

@@ -9,7 +9,6 @@
 
 Важно:
 
-- legacy-операция `SendDirectMessage` отключена и не зарегистрирована в публичном API;
 - для DM v1 нужно использовать `SendMessagePair`, `ReceiveOutcomingMessage`, `ReceiveIncomingMessage`, `DeleteMessage`, `DeleteConversation`, `GetDirectMessages`;
 - `DmSyncBatch` предназначен для межсерверной догоняющей синхронизации, не для обычного клиентского UI.
 

docs/API/13_User_Settings_API.md

@@ -0,0 +1,98 @@
+# API пользовательских настроек
+
+Этот раздел описывает `user_settings` - отдельное хранилище пользовательских настроек, не связанное с `users_params` и не связанное с legacy DM-таблицами.
+
+## 1. Назначение
+
+`user_settings` хранит технические пользовательские настройки, которые должны синхронизироваться между максимум двумя access/sync-серверами пользователя.
+
+Основной текущий кейс:
+
+- `setting_type = 1` - курсор прочитанности канала;
+- `setting_key = ownerBlockchainName/channelName`;
+- `value_num = number of messages already seen in channel`;
+- `value_text = ''`.
+
+Если настройки нет, канал считается просмотренным до конца, то есть unread = `0`.
+
+## 2. Структура записи
+
+- `login` - логин владельца настройки;
+- `setting_type` - числовой код типа настройки;
+- `setting_key` - строковый ключ настройки;
+- `time_ms` - время установки значения в миллисекундах;
+- `value_text` - строковое значение;
+- `value_num` - числовое значение;
+- `client_key` - публичный Ed25519 ключ клиента в Base64;
+- `signature` - Ed25519 подпись preimage в Base64;
+- `synced` - была ли настройка успешно доставлена на второй сервер.
+
+Уникальность: `(login, setting_type, setting_key)`.
+Обновление: только если `time_ms` новее текущего значения.
+
+## 3. Формат подписи
+
+Подписывается строка:
+
+`SHiNe/UserSettings:|login|setting_type|setting_key|time_ms|value_text|value_num`
+
+Где внутри полей используется экранирование `\` и `|`.
+
+Подпись создаётся клиентским `client_key`.
+
+## 4. Операции
+
+### `UpsertUserSetting`
+
+Записывает или обновляет настройку пользователя.
+
+Если запрос пришёл от клиента, сервер:
+
+- сохраняет запись локально;
+- пытается сразу отправить её на доступный sync-сервер;
+- если отправка успешна, помечает запись как `synced=true`;
+- если нет, оставляет `synced=false`.
+
+Если запрос пришёл по синхронизации между серверами, используется `sync_delivery=true`, и повторной пересылки дальше не делается.
+
+### `GetUserSetting`
+
+Чтение одной настройки по `(login, setting_type, setting_key)`.
+
+### `ListUserSettings`
+
+Список всех настроек пользователя.
+
+### `UserSettingsSyncBatch`
+
+Внутренний межсерверный batch-эндпоинт.
+
+- отдаёт настройки, новые относительно курсора;
+- используется для bootstrap и догрузки после восстановления;
+- применяется только для пользователей, чей сервер есть в `access_servers`.
+
+### `MarkAllUserSettingsUnsynced`
+
+Внутренний служебный запрос.
+
+- помечает все настройки пользователя или все настройки сразу как `synced=false`;
+- нужен после добавления нового sync-сервера или при потере локальной БД.
+
+## 5. Синхронизация
+
+Синхронизация настроек работает отдельно от DM.
+
+- локальная запись создаётся с `synced=false`, если её ещё не подтвердил второй сервер;
+- если запись пришла с другого сервера, она сохраняется сразу как `synced=true`;
+- периодический sync раз в 6 часов проверяет несинхронизированные записи и догружает новые записи по курсору;
+- если появляется новый sync-сервер или локальная БД была потеряна, нужно пометить все настройки несинхронизированными и заново догрузить batch с нуля.
+
+## 6. Текущий UI-кейс
+
+UI при открытии канала отправляет `UpsertUserSetting` с:
+
+- `setting_type = 1`;
+- `setting_key = ownerBlockchainName/channelName`;
+- `value_num = количество уже просмотренных сообщений в канале`.
+
+Это значение используется сервером для расчёта unread в списке каналов и в канале.

docs/API/15_Notifications_API.md

@@ -0,0 +1,81 @@
+# API для разработчиков: уведомления
+
+Документ описывает чтение пользовательских уведомлений, которые сервер индексирует при `AddBlock`.
+
+Текущая операция:
+
+- `GetNotifications`
+
+## 1. `GetNotifications`
+
+Метод читает уведомления текущего пользователя. В `payload.login` можно передать логин явно, но обычно клиент использует авторизованную сессию.
+
+Возвращаются две отдельные ленты:
+
+- `replies` — ответы на сообщения пользователя в каналах и тредах;
+- `events` — события добавления в `close_friend`.
+
+### Запрос
+
+```json
+{
+  "op": "GetNotifications",
+  "requestId": "notif-001",
+  "payload": {
+    "login": "alice",
+    "limit": 50
+  }
+}
+```
+
+### Успешный ответ
+
+```json
+{
+  "op": "GetNotifications",
+  "requestId": "notif-001",
+  "status": 200,
+  "ok": true,
+  "payload": {
+    "login": "Alice",
+    "replies": [
+      {
+        "kind": "reply",
+        "createdAtMs": 1755673200000,
+        "sourceLogin": "Bob",
+        "sourceBlockchainName": "bob-001",
+        "sourceBlockNumber": 42,
+        "sourceBlockHash": "ab12...",
+        "sourceMsgSubType": 20,
+        "sourceText": "Спасибо!",
+        "targetLogin": "Alice",
+        "targetBlockchainName": "alice-001",
+        "targetBlockNumber": 18,
+        "targetBlockHash": "cd34..."
+      }
+    ],
+    "events": [
+      {
+        "kind": "close_friend",
+        "createdAtMs": 1755673300000,
+        "sourceLogin": "Kate",
+        "sourceBlockchainName": "kate-001",
+        "sourceBlockNumber": 7,
+        "sourceBlockHash": "ef56...",
+        "sourceMsgSubType": 10,
+        "sourceText": "close_friend",
+        "targetLogin": "Alice",
+        "targetBlockchainName": "alice-001",
+        "targetBlockNumber": 0,
+        "targetBlockHash": "0000..."
+      }
+    ]
+  }
+}
+```
+
+### Примечание
+
+- `replies` заполняется только для `TEXT_REPLY`.
+- `events` заполняется только для входящего `CONNECTION_FRIEND` / `close_friend`.
+- Другие типы связей в эту ленту не попадают.

docs/Blockchain/sync-between-servers.md

@@ -19,6 +19,10 @@
 Каждый сервер регистрирует в своей Solana PDA список `sync_servers` —
 логины SHiNE-аккаунтов партнёрских серверов, с которыми он синхронизируется.
 
+Важно: в текущей архитектуре у пользователя одновременно может быть не более
+двух sync/access-серверов. Это ограничение считается обязательным для runtime-логики
+`synced` и пользовательских курсоров.
+
 - Список хранится в блоке `ServerProfileBlock` внутри `user_pda` сервера.
 - Адрес каждого партнёрского сервера читается из его PDA на Solana.
 - Синхронизация двусторонняя: оба сервера должны иметь друг друга в `sync_servers`.
@@ -39,6 +43,13 @@
 - Порядок блоков сохраняется (по глобальному номеру блока и хэшу).
 - Дедупликация по глобальному номеру блока и хэшу.
 
+### 3.3 Пользовательские настройки
+
+- Отдельная таблица `user_settings`.
+- Синхронизируются технические настройки пользователя, включая курсор прочитанности каналов.
+- Для текущего UI-кейса хранится `setting_type = 1` и `setting_key = ownerBlockchainName/channelName`.
+- Синхронизация идёт с учётом `time_ms` и флага `synced`.
+
 ## 4. Текущая реализованная схема
 
 На текущем этапе сервер уже умеет базовую межсерверную синхронизацию пользовательских блокчейнов.

docs/Personal_Messages/Протокол_DM_v1.md

@@ -334,8 +334,6 @@
 
 ### 8.2. Новые методы, которые нужны
 
-Отдельный legacy-метод `SendDirectMessage` в DM v1 не используется и должен оставаться отключённым, чтобы не было параллельного старого стека доставки.
-
 ## 9. Правила валидации и применения
 
 ### 9.1. Общее правило по ревизиям
@@ -653,7 +651,6 @@ UI-следствие для клиента:
 - межсерверная маршрутизация DM должна идти через `access_servers`;
 - сервер должен добирать отсутствующих пользователей из Solana PDA до проверки подписи DM;
 - при выборе актуальной версии должен учитываться `reencryptedAtMs`, если `revisionTimeMs` совпадает;
-- legacy `SendDirectMessage` должен быть отключён;
 - логика должна быть безопасна для нескольких серверов у каждой стороны.
 
 ## 14. Что в v1 пока не входит

shine-UI/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta
       name="viewport"
-      content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover"
+      content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover, interactive-widget=resizes-visual"
     />
     <base href="/" />
     <link rel="manifest" href="./manifest.webmanifest" />
@@ -12,7 +12,7 @@
     <link rel="apple-touch-icon" href="./img/logo.jpg" />
     <title>СИЯНИЕ</title>
     <script>
-window.__SHINE_BUILD_HASH__ = '20260806223040';
+window.__SHINE_BUILD_HASH__ = '20260819190000';
       window.__SHINE_CLIENT_VERSION__ = '1.2.10';
     </script>
     <script>

shine-UI/js/app.js

@@ -82,7 +82,7 @@ import * as solanaUsersInitView from './pages/solana-users-init-view.js';
 import * as solanaRpcCheckView from './pages/solana-rpc-check-view.js';
 import * as messagesList from './pages/messages-list.js';
 import * as contactSearchView from './pages/contact-search-view.js';
-import * as chatView from './pages/chat-view.js?v=202607152145';
+import * as chatView from './pages/chat-view.js?v=202608191738';
 import * as userProfileView from './pages/user-profile-view.js';
 import * as channelsList from './pages/channels-list.js';
 import * as channelView from './pages/channel-view.js';
@@ -221,6 +221,62 @@ function setKeyboardOffsetPx(valuePx = 0) {
   setShellMetricVar('--keyboard-offset', valuePx);
 }
 
+let stableViewportHeightPx = Math.max(
+  1,
+  Math.round(window.innerHeight || document.documentElement?.clientHeight || window.visualViewport?.height || 0),
+);
+
+function isTextEntryFocused() {
+  const active = document.activeElement;
+  return active instanceof HTMLTextAreaElement
+    || (active instanceof HTMLInputElement && !['button', 'checkbox', 'radio', 'range', 'file', 'submit', 'reset'].includes(active.type));
+}
+
+function syncViewportMetrics() {
+  if (!appShellEl) return;
+  const viewport = window.visualViewport || null;
+  const currentLayoutHeightPx = Math.max(
+    1,
+    Math.round(window.innerHeight || document.documentElement?.clientHeight || viewport?.height || 0),
+  );
+  const widthPx = Math.max(1, Math.round(window.innerWidth || viewport?.width || 0));
+  const offsetLeftPx = Math.max(0, Math.round(viewport?.offsetLeft || 0));
+  const textEntryFocused = isTextEntryFocused();
+
+  // Android Chrome/Firefox могут уменьшать и visualViewport, и innerHeight.
+  // Поэтому высоту экрана до открытия клавиатуры запоминаем отдельно и во
+  // время ввода НЕ переписываем ею app-shell. Иначе toolbar тоже поднимется.
+  if (!textEntryFocused) {
+    stableViewportHeightPx = Math.max(stableViewportHeightPx, currentLayoutHeightPx);
+    // После поворота/реального resize разрешаем уменьшить базу, но только
+    // когда никакое текстовое поле не держит экранную клавиатуру.
+    if (Math.abs(stableViewportHeightPx - currentLayoutHeightPx) > 220) {
+      stableViewportHeightPx = currentLayoutHeightPx;
+    }
+  } else if (currentLayoutHeightPx > stableViewportHeightPx) {
+    stableViewportHeightPx = currentLayoutHeightPx;
+  }
+
+  const visualBottomPx = viewport
+    ? Math.round((viewport.offsetTop || 0) + viewport.height)
+    : currentLayoutHeightPx;
+  const rawKeyboardOffsetPx = Math.max(
+    0,
+    stableViewportHeightPx - Math.min(currentLayoutHeightPx, visualBottomPx),
+  );
+  // Address bar Android обычно даёт небольшую дельту; клавиатура — заметно больше.
+  const keyboardOffsetPx = textEntryFocused && rawKeyboardOffsetPx >= 100
+    ? rawKeyboardOffsetPx
+    : 0;
+
+  setShellMetricVar('--app-viewport-width', widthPx);
+  setShellMetricVar('--app-viewport-height', keyboardOffsetPx > 0 ? stableViewportHeightPx : currentLayoutHeightPx);
+  setShellMetricVar('--app-viewport-offset-top', 0);
+  setShellMetricVar('--app-viewport-offset-left', offsetLeftPx);
+  setKeyboardOffsetPx(keyboardOffsetPx);
+  appShellEl.classList.toggle('keyboard-open', keyboardOffsetPx > 0);
+}
+
 function attachSlotHeightObserver(slotEl, cssVarName) {
   if (!slotEl || typeof ResizeObserver !== 'function') return null;
   const sync = () => {
@@ -237,6 +293,55 @@ const topbarHeightObserver = attachSlotHeightObserver(topbarEl, '--topbar-height
 const composerHeightObserver = attachSlotHeightObserver(composerEl, '--composer-height');
 const toolbarHeightObserver = attachSlotHeightObserver(toolbarEl, '--toolbar-height');
 
+syncViewportMetrics();
+window.visualViewport?.addEventListener('resize', syncViewportMetrics);
+window.visualViewport?.addEventListener('scroll', syncViewportMetrics);
+window.addEventListener('resize', syncViewportMetrics);
+document.addEventListener('focusin', () => {
+  requestAnimationFrame(syncViewportMetrics);
+  // Samsung One UI / Firefox can finish the OSK viewport transition several
+  // frames after focus. Re-sample through the animation instead of trusting
+  // the first resize event.
+  window.setTimeout(syncViewportMetrics, 80);
+  window.setTimeout(syncViewportMetrics, 180);
+  window.setTimeout(syncViewportMetrics, 320);
+});
+document.addEventListener('focusout', () => {
+  window.setTimeout(syncViewportMetrics, 80);
+  window.setTimeout(syncViewportMetrics, 220);
+});
+
+// Optional on-device viewport diagnostics: append ?keyboard-debug=1 to the URL.
+if (new URLSearchParams(window.location.search).get('keyboard-debug') === '1') {
+  const debugEl = document.createElement('pre');
+  debugEl.id = 'keyboard-viewport-debug';
+  Object.assign(debugEl.style, {
+    position: 'fixed', top: '4px', right: '4px', zIndex: '999999', margin: '0',
+    maxWidth: '94vw', padding: '6px 8px', fontSize: '10px', lineHeight: '1.25',
+    color: '#fff', background: 'rgba(0,0,0,.82)', pointerEvents: 'none',
+    whiteSpace: 'pre-wrap',
+  });
+  document.body.append(debugEl);
+  const syncDebug = () => {
+    const vv = window.visualViewport;
+    debugEl.textContent = [
+      `innerHeight=${window.innerHeight}`,
+      `clientHeight=${document.documentElement.clientHeight}`,
+      `vv.height=${vv ? Math.round(vv.height) : 'n/a'}`,
+      `vv.offsetTop=${vv ? Math.round(vv.offsetTop) : 'n/a'}`,
+      `stable=${stableViewportHeightPx}`,
+      `keyboard=${getComputedStyle(appShellEl).getPropertyValue('--keyboard-offset').trim()}`,
+      `focused=${isTextEntryFocused()}`,
+    ].join(' | ');
+  };
+  window.visualViewport?.addEventListener('resize', syncDebug);
+  window.visualViewport?.addEventListener('scroll', syncDebug);
+  window.addEventListener('resize', syncDebug);
+  document.addEventListener('focusin', () => window.setTimeout(syncDebug, 330));
+  document.addEventListener('focusout', () => window.setTimeout(syncDebug, 230));
+  syncDebug();
+}
+
 function clearSlot(slotEl, cssVarName) {
   if (!slotEl) return;
   slotEl.innerHTML = '';

shine-UI/js/pages/channel-view.js

@@ -234,6 +234,12 @@ function buildThreadRoute(messageRef, selector) {
   });
 }
 
+function buildChannelSettingsKey(ownerBlockchainName, channelName) {
+  const ownerBch = String(ownerBlockchainName || '').trim();
+  const name = String(channelName || '').trim();
+  return `${ownerBch}/${name}`;
+}
+
 function firstNonEmptyText(...candidates) {
   for (const candidate of candidates) {
     if (typeof candidate !== 'string') continue;
@@ -1249,6 +1255,8 @@ function mapApiMessageToPost(message, selector, localNumber) {
 async function loadFromApi(route, channelId) {
   const currentSessionLogin = String(state.session.login || '').trim();
   const isAuthorized = !!currentSessionLogin;
+  let unreadCount = 0;
+  let messagesCount = 0;
   let cachedFeed = null;
   const ensureFeed = async () => {
     if (cachedFeed) return cachedFeed;
@@ -1309,6 +1317,9 @@ async function loadFromApi(route, channelId) {
   }
 
   if (selector?.ownerBlockchainName && selector?.channelName) {
+    let unreadCount = 0;
+    let messagesCount = 0;
+
     const routeOwnerRaw = String(selector.ownerBlockchainName || '').trim();
     const routeOwnerNormalized = routeOwnerRaw.toLowerCase();
     const routeOwnerLoginFromBch = extractLoginFromBlockchainName(routeOwnerRaw);
@@ -1358,6 +1369,8 @@ async function loadFromApi(route, channelId) {
     if (!channel?.channel?.ownerBlockchainName || channel?.channel?.channelRoot?.blockNumber == null) {
       throw new Error('Канал не найден.');
     }
+    unreadCount = Number(channel?.unreadCount || 0);
+    messagesCount = Number(channel?.messagesCount || 0);
     selector = {
       ownerBlockchainName: String(channel.channel.ownerBlockchainName),
       channelRootBlockNumber: Number(channel.channel.channelRoot.blockNumber),
@@ -1374,6 +1387,7 @@ async function loadFromApi(route, channelId) {
   const messages = Array.isArray(payload.messages) ? payload.messages : [];
   let reverseChannelMissingWarning = '';
   let mergedMessages = [...messages];
+  if (!messagesCount) messagesCount = mergedMessages.length;
 
   const currentLogin = currentSessionLogin;
   const ownerLogin = String(payload.channel?.ownerLogin || '').trim();
@@ -1445,6 +1459,8 @@ async function loadFromApi(route, channelId) {
     posts,
     metaEvents: Array.isArray(payload?.metaEvents) ? payload.metaEvents : [],
     reverseChannelMissingWarning,
+    unreadCount,
+    messagesCount,
     isOwnChannel,
     isSubscribed,
     selector,
@@ -1905,6 +1921,13 @@ function renderBody(screen, navigate, routeKey, channelData, handlers) {
     screen.append(reverseWarning);
   }
 
+  if (Number(channelData.unreadCount || 0) > 0) {
+    const unreadLine = document.createElement('div');
+    unreadLine.className = 'card channel-unread-line';
+    unreadLine.textContent = `Не прочитано: ${channelData.unreadCount}`;
+    screen.append(unreadLine);
+  }
+
   const actionButton = document.createElement('button');
   actionButton.className = 'destructive-btn channel-main-action';
   actionButton.textContent = 'Подписаться на канал';
@@ -1995,7 +2018,7 @@ function renderBody(screen, navigate, routeKey, channelData, handlers) {
     screen.append(feed, backButton);
   }
 
-  applyPendingScroll(screen, routeKey, channelData.isOwnChannel || channelData.isDiary);
+  applyPendingScroll(screen, routeKey, channelData.isOwnChannel || channelData.isDiary || Number(channelData.unreadCount || 0) === 0);
   return () => {
     // noop
   };
@@ -2294,6 +2317,19 @@ export function render({ navigate, route, chrome }) {
     try {
       const apiData = await loadFromApi(route, channelId);
       activeSelector = apiData?.selector || null;
+      const lastSeenCount = Number(apiData?.messagesCount || (Array.isArray(apiData?.posts) ? apiData.posts.length : 0) || 0);
+      const settingKey = buildChannelSettingsKey(apiData?.channel?.ownerBlockchainName, apiData?.channel?.name);
+      if (settingKey && state.session.login && state.session.storagePwdInMemory) {
+        void authService.upsertUserSetting({
+          login: state.session.login,
+          settingType: 1,
+          settingKey,
+          timeMs: Date.now(),
+          valueText: '',
+          valueNum: lastSeenCount,
+          storagePwd: state.session.storagePwdInMemory,
+        }).catch(() => {});
+      }
       const titleLabel = apiData?.channel?.displayTitle || apiData?.channel?.name || 'channel';
       const entrypointPosts = getEntrypointPosts(apiData?.posts);
       const openEntrypointHistory = () => {

shine-UI/js/pages/chat-view.js

@@ -572,12 +572,27 @@ function scrollToUnreadSeparator(list) {
   return true;
 }
 
-function renderLog(list, chatId, { onOpenActions, markAsRead = true, scrollMode = 'latest' } = {}) {
+function renderLog(
+  list,
+  chatId,
+  {
+    onOpenActions,
+    markAsRead = true,
+    scrollMode = 'latest',
+    showUnreadSeparator = true,
+    unreadSeparatorMessageKey = '',
+  } = {},
+) {
   list.innerHTML = '';
   const messages = getChatMessages(chatId);
   let unreadSeparatorInserted = false;
+  const separatorMessageKey = String(unreadSeparatorMessageKey || '').trim();
   messages.forEach((msg) => {
-    if (!unreadSeparatorInserted && msg?.from === 'in' && msg?.unread) {
+    const isUnreadBoundary = showUnreadSeparator
+      && !unreadSeparatorInserted
+      && separatorMessageKey
+      && String(msg?.messageKey || '').trim() === separatorMessageKey;
+    if (isUnreadBoundary) {
       const sep = document.createElement('div');
       sep.className = 'chat-unread-separator';
       const label = document.createElement('span');
@@ -781,12 +796,8 @@ async function mergeDirectMessagesPage(chatId, payloadMessages) {
   }
 }
 
-function setChatKeyboardOpen(isOpen) {
-  document.body.classList.toggle('chat-keyboard-open', !!isOpen);
-  document.body.classList.toggle('chat-toolbar-persistent', !!isOpen);
-}
-
 export function render({ navigate, route, chrome }) {
+  document.body.classList.add('chat-topbar-overlay');
   const routeChatId = route.params.chatId || 'u1';
   const chatId = normalizeDmChatId(routeChatId) || 'u1';
   const contact = directMessages.find((d) => normalizeDmChatId(d.id) === chatId) || {
@@ -800,12 +811,53 @@ export function render({ navigate, route, chrome }) {
   const isTextToSpeechReady = isTextToSpeechConfigured(state.entrySettings);
   const isKnownContact = (state.contacts || []).some((x) => String(x || '').toLowerCase() === String(chatId || '').toLowerCase());
   const hasUnreadIncoming = getChatMessages(chatId).some((msg) => msg?.from === 'in' && msg?.unread);
+  const UNREAD_SEPARATOR_AUTO_HIDE_MS = 5000;
   let historyHasMore = true;
   let historyLoading = false;
   let historyNextBeforeTimeMs = 0;
   let historyNextBeforeMessageKey = '';
   let historyBootstrapped = false;
   let boundScrollContainer = null;
+  let unreadSeparatorVisible = hasUnreadIncoming;
+  let unreadSeparatorHideTimer = null;
+  let unreadSeparatorAnchorMessageKey = getChatMessages(chatId).find((msg) => msg?.from === 'in' && msg?.unread)?.messageKey || '';
+
+  const clearUnreadSeparatorHideTimer = () => {
+    if (unreadSeparatorHideTimer) {
+      window.clearTimeout(unreadSeparatorHideTimer);
+      unreadSeparatorHideTimer = null;
+    }
+  };
+
+  const renderChatLog = ({ scrollMode = 'latest', markAsRead = true } = {}) => {
+    renderLog(log, chatId, {
+      onOpenActions: handleOpenActions,
+      markAsRead,
+      scrollMode,
+      showUnreadSeparator: unreadSeparatorVisible,
+      unreadSeparatorMessageKey: unreadSeparatorAnchorMessageKey,
+    });
+    if (unreadSeparatorVisible) {
+      scheduleUnreadSeparatorAutoHide();
+    }
+  };
+
+  const hideUnreadSeparator = ({ rerender = true } = {}) => {
+    clearUnreadSeparatorHideTimer();
+    if (!unreadSeparatorVisible) return;
+    unreadSeparatorVisible = false;
+    if (rerender) {
+      renderChatLog({ scrollMode: 'latest', markAsRead: false });
+    }
+  };
+
+  const scheduleUnreadSeparatorAutoHide = () => {
+    clearUnreadSeparatorHideTimer();
+    if (!unreadSeparatorVisible) return;
+    unreadSeparatorHideTimer = window.setTimeout(() => {
+      hideUnreadSeparator({ rerender: true });
+    }, UNREAD_SEPARATOR_AUTO_HIDE_MS);
+  };
 
   const handleReadAloud = async (msg) => {
     if (!isTextToSpeechConfigured(state.entrySettings)) {
@@ -819,13 +871,13 @@ export function render({ navigate, route, chrome }) {
   const handleStartCall = async (mode = 'audio') => {
     try {
       await startOutgoingCall(chatId, { mode });
-      renderLog(log, chatId, { onOpenActions: handleOpenActions });
+      renderChatLog({ scrollMode: 'latest', markAsRead: false });
     } catch (e) {
       addSystemChatMessage(chatId, `[Звонок] Ошибка запуска: ${e.message || 'unknown'}`, {
         from: 'out',
         kind: 'call-tech',
       });
-      renderLog(log, chatId, { onOpenActions: handleOpenActions });
+      renderChatLog({ scrollMode: 'latest', markAsRead: false });
     }
   };
 
@@ -848,11 +900,7 @@ export function render({ navigate, route, chrome }) {
       unread: false,
       rawBlobB64: String(result?.localBlobB64 || ''),
     });
-    renderLog(log, chatId, {
-      onOpenActions: handleOpenActions,
-      markAsRead: false,
-      scrollMode: 'latest',
-    });
+    renderChatLog({ scrollMode: 'latest', markAsRead: false });
     notifyUnreadStateUpdated();
   };
 
@@ -1010,29 +1058,6 @@ export function render({ navigate, route, chrome }) {
   let inputFocused = false;
   let emojiPickerOpen = false;
   let emojiSelection = null;
-  const baseViewportHeight = Math.max(window.visualViewport?.height || 0, window.innerHeight || 0);
-  const appShell = document.querySelector('.app-shell');
-
-  const setKeyboardInset = (valuePx = 0) => {
-    appShell?.style.setProperty('--keyboard-offset', `${Math.max(0, Math.ceil(Number(valuePx || 0)))}px`);
-  };
-
-  const syncKeyboardUi = () => {
-    const viewport = window.visualViewport || null;
-    const viewportHeight = Math.max(viewport?.height || 0, window.innerHeight || 0);
-    const viewportShrunk = baseViewportHeight - viewportHeight > 120;
-    const keyboardInset = viewportShrunk
-      ? Math.max(0, baseViewportHeight - viewportHeight)
-      : 0;
-    setKeyboardInset(keyboardInset);
-    setChatKeyboardOpen(inputFocused && viewportShrunk);
-    if (viewportShrunk && window.scrollY !== 0) {
-      window.scrollTo(0, 0);
-    }
-    if (inputFocused) {
-      window.requestAnimationFrame(() => scrollToLatestMessage(log));
-    }
-  };
 
   const setHistoryLoadingState = (isLoading) => {
     historyLoader.hidden = !isLoading;
@@ -1235,20 +1260,21 @@ export function render({ navigate, route, chrome }) {
     if (activeEdit?.messageKey && activeEdit.messageKey === String(msg?.messageKey || '')) {
       cancelEditMode({ restoreDraft: true });
     }
-    renderLog(log, chatId, { onOpenActions: handleOpenActions });
+    renderChatLog({ scrollMode: 'latest', markAsRead: false });
   };
 
   const sendTextMessage = async (rawText) => {
     const safeText = sanitizeUserDmTextForSend(String(rawText || ''));
     const text = safeText.trim();
     if (!text) return;
+    hideUnreadSeparator({ rerender: false });
     const editing = activeEdit;
     const replying = !editing ? activeReply : null;
     const finalText = editing
       ? `${String(editing?.prefixText || '')}${text}`
       : `${replying ? buildDmReplyTechBlock({ baseKey: replying.baseKey }) : ''}${text}`;
     const tempId = editing ? '' : addOutgoingPendingMessage(chatId, text);
-    renderLog(log, chatId, { onOpenActions: handleOpenActions });
+    renderChatLog({ scrollMode: 'latest', markAsRead: false });
     scrollToLatestMessageSmart(log, { smoothIfNearBottom: true });
 
     try {
@@ -1288,7 +1314,7 @@ export function render({ navigate, route, chrome }) {
         cancelReplyMode({ restoreDraft: false });
       }
 
-      renderLog(log, chatId, { onOpenActions: handleOpenActions });
+      renderChatLog({ scrollMode: 'latest', markAsRead: false });
       if (localRevisionApplied) {
         notifyUnreadStateUpdated();
       }
@@ -1331,7 +1357,7 @@ export function render({ navigate, route, chrome }) {
           error: e?.message || 'unknown',
         },
       });
-      renderLog(log, chatId, { onOpenActions: handleOpenActions });
+      renderChatLog({ scrollMode: 'latest', markAsRead: false });
     }
   };
 
@@ -1393,7 +1419,7 @@ export function render({ navigate, route, chrome }) {
       historyNextBeforeTimeMs = Number(payload?.nextBeforeTimeMs || 0);
       historyNextBeforeMessageKey = String(payload?.nextBeforeMessageKey || '').trim();
       historyBootstrapped = true;
-      renderLog(log, chatId, { onOpenActions: handleOpenActions, markAsRead: false, scrollMode: preserveScroll ? 'preserve' : 'latest' });
+      renderChatLog({ markAsRead: false, scrollMode: preserveScroll ? 'preserve' : 'latest' });
       if (preserveScroll) {
         window.requestAnimationFrame(() => {
           const nextHeight = Number(scrollContainer?.scrollHeight || 0);
@@ -1445,12 +1471,12 @@ export function render({ navigate, route, chrome }) {
   input?.addEventListener('focus', () => {
     rememberEmojiSelection();
     inputFocused = true;
-    syncKeyboardUi();
-    scrollToLatestMessage(log);
+    window.requestAnimationFrame(() => {
+      if (inputFocused) scrollToLatestMessage(log);
+    });
   });
   input?.addEventListener('blur', () => {
     inputFocused = false;
-    setChatKeyboardOpen(false);
   });
   emojiToggle?.setAttribute('aria-expanded', 'false');
   emojiToggle?.addEventListener('pointerdown', (event) => {
@@ -1493,25 +1519,34 @@ export function render({ navigate, route, chrome }) {
   const handleIncomingChatRefresh = async (event) => {
     const updatedChatId = normalizeDmChatId(event?.detail?.chatId);
     if (updatedChatId !== chatId) return;
+    if (Number(event?.detail?.messageType || 0) === 1) {
+      if (!unreadSeparatorVisible) {
+        unreadSeparatorAnchorMessageKey = getChatMessages(chatId).find((msg) => msg?.from === 'in' && msg?.unread)?.messageKey || unreadSeparatorAnchorMessageKey;
+        unreadSeparatorVisible = Boolean(unreadSeparatorAnchorMessageKey);
+      }
+      scheduleUnreadSeparatorAutoHide();
+    }
     preserveComposerSelection(input, () => {
-      renderLog(log, chatId, { onOpenActions: handleOpenActions, scrollMode: 'latest' });
+      renderChatLog({ scrollMode: 'latest' });
     });
     window.requestAnimationFrame(() => scrollToLatestMessage(log));
     void sendReadReceiptsForVisible(chatId);
   };
 
   window.addEventListener('shine-chat-messages-updated', handleIncomingChatRefresh);
-  window.visualViewport?.addEventListener('resize', syncKeyboardUi);
-  window.addEventListener('resize', syncKeyboardUi);
 
-  chrome?.setComposer(form);
   wrap.append(historyLoader, log);
   screen.append(wrap);
+  chrome?.setComposer(form);
   renderLog(log, chatId, {
     onOpenActions: handleOpenActions,
     markAsRead: false,
     scrollMode: hasUnreadIncoming ? 'unread' : 'latest',
+    showUnreadSeparator: unreadSeparatorVisible,
   });
+  if (unreadSeparatorVisible) {
+    scheduleUnreadSeparatorAutoHide();
+  }
   window.setTimeout(() => {
     if (markChatRead(chatId) > 0) {
       notifyUnreadStateUpdated();
@@ -1519,18 +1554,18 @@ export function render({ navigate, route, chrome }) {
   }, 220);
   void sendReadReceiptsForVisible(chatId);
   window.requestAnimationFrame(() => {
-    boundScrollContainer = log.closest('.screen-content') || wrap.parentElement || wrap;
+    boundScrollContainer = wrap;
     boundScrollContainer?.addEventListener('scroll', handleHistoryScroll, { passive: true });
     void loadHistoryPage({ preserveScroll: true });
   });
   screen.cleanup = () => {
-    setChatKeyboardOpen(false);
-    setKeyboardInset(0);
+    hideUnreadSeparator({ rerender: false });
     stopAllTwemojiAnimations();
     window.removeEventListener('shine-chat-messages-updated', handleIncomingChatRefresh);
-    window.visualViewport?.removeEventListener('resize', syncKeyboardUi);
-    window.removeEventListener('resize', syncKeyboardUi);
     boundScrollContainer?.removeEventListener('scroll', handleHistoryScroll);
+    clearUnreadSeparatorHideTimer();
+    document.body.classList.remove('chat-topbar-overlay');
+    chrome?.setComposer(null);
   };
   return screen;
 }

shine-UI/js/pages/messages-list.js

@@ -82,6 +82,15 @@ function formatChatRowTime(ts) {
   }).format(new Date(value));
 }
 
+function compareChatRows(a, b) {
+  const timeA = Number(a?.lastTimeMs || 0);
+  const timeB = Number(b?.lastTimeMs || 0);
+  if (timeA !== timeB) return timeB - timeA;
+  const nameA = String(a?.name || '').toLowerCase();
+  const nameB = String(b?.name || '').toLowerCase();
+  return nameA.localeCompare(nameB, 'ru');
+}
+
 const SVG_CHEVRON = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M9 6l6 6-6 6"/></svg>';
 
 export function render({ navigate, chrome }) {
@@ -99,11 +108,103 @@ export function render({ navigate, chrome }) {
       </div>
     </div>
     <h1 class="dm-head-title">Контакты</h1>
-    <button type="button" class="dm-head-plus" aria-label="Новый диалог">+</button>
+    <div class="dm-head-menu-wrap">
+      <button type="button" class="dm-head-menu-btn" aria-label="Меню контактов" aria-haspopup="menu" aria-expanded="false">
+        <span class="dm-head-menu-dots" aria-hidden="true"><i></i><i></i><i></i></span>
+      </button>
+      <div class="dm-head-menu" role="menu" hidden>
+        <button type="button" class="dm-head-menu-item" role="menuitem" data-action="search-contacts">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <circle cx="11" cy="11" r="6.5"></circle>
+            <path d="M16 16l4 4"></path>
+          </svg>
+          <span>Поиск контактов</span>
+        </button>
+      </div>
+    </div>
   `;
   const headName = head.querySelector('.dm-head-name');
   if (headName) headName.textContent = login;
-  head.querySelector('.dm-head-plus')?.addEventListener('click', () => navigate('contact-search-view'));
+
+  const menuWrap = head.querySelector('.dm-head-menu-wrap');
+  const menuButton = head.querySelector('.dm-head-menu-btn');
+  const menuTemplate = head.querySelector('.dm-head-menu');
+  // The header itself is mounted into chrome/topbar, whose hit-test area ends at the
+  // header bounds. A dropdown overflowing below it can look visible but clicks may
+  // land on the content layer underneath. Render the open menu as a body portal.
+  menuTemplate?.remove();
+
+  let menuPortal = null;
+
+  const closeHeadMenu = () => {
+    menuPortal?.remove();
+    menuPortal = null;
+    menuButton?.setAttribute('aria-expanded', 'false');
+    menuWrap?.classList.remove('is-open');
+  };
+
+  const positionHeadMenu = () => {
+    if (!menuPortal || !menuButton) return;
+    const rect = menuButton.getBoundingClientRect();
+    const margin = 10;
+    const menuWidth = menuPortal.offsetWidth || 206;
+    const left = Math.max(margin, Math.min(window.innerWidth - menuWidth - margin, rect.right - menuWidth));
+    menuPortal.style.left = `${Math.round(left)}px`;
+    menuPortal.style.top = `${Math.round(rect.bottom + 7)}px`;
+  };
+
+  const openHeadMenu = () => {
+    if (!menuButton || menuPortal) return;
+    const portal = document.createElement('div');
+    portal.className = 'dm-head-menu dm-head-menu--portal';
+    portal.setAttribute('role', 'menu');
+    portal.innerHTML = `
+      <button type="button" class="dm-head-menu-item" role="menuitem" data-action="search-contacts">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+          <circle cx="11" cy="11" r="6.5"></circle>
+          <path d="M16 16l4 4"></path>
+        </svg>
+        <span>Поиск контактов</span>
+      </button>
+    `;
+
+    portal.querySelector('[data-action="search-contacts"]')?.addEventListener('click', (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      closeHeadMenu();
+      navigate('contact-search-view');
+    });
+    portal.addEventListener('click', (event) => event.stopPropagation());
+
+    document.body.append(portal);
+    menuPortal = portal;
+    menuButton.setAttribute('aria-expanded', 'true');
+    menuWrap?.classList.add('is-open');
+    positionHeadMenu();
+  };
+
+  menuButton?.addEventListener('click', (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    if (menuPortal) closeHeadMenu();
+    else openHeadMenu();
+  });
+
+  const onOutsideClick = (event) => {
+    if (!menuPortal) return;
+    if (menuPortal.contains(event.target) || menuButton?.contains(event.target)) return;
+    closeHeadMenu();
+  };
+  const onMenuKeydown = (event) => {
+    if (event.key !== 'Escape' || !menuPortal) return;
+    closeHeadMenu();
+    menuButton?.focus();
+  };
+  const onMenuViewportChange = () => positionHeadMenu();
+  document.addEventListener('click', onOutsideClick);
+  document.addEventListener('keydown', onMenuKeydown);
+  window.addEventListener('resize', onMenuViewportChange, { passive: true });
+  window.addEventListener('scroll', onMenuViewportChange, { passive: true, capture: true });
 
   const divider = document.createElement('div');
   divider.className = 'dm-divider';
@@ -175,6 +276,7 @@ export function render({ navigate, chrome }) {
           time: formatChatRowTime(lastTimeMs),
           unread,
           notInContacts: false,
+          lastTimeMs,
         };
       });
 
@@ -197,10 +299,11 @@ export function render({ navigate, chrome }) {
             time: formatChatRowTime(lastTimeMs),
             unread,
             notInContacts: true,
+            lastTimeMs,
           };
         });
 
-      const rows = [...contactRows, ...extraRows];
+      const rows = [...contactRows, ...extraRows].sort(compareChatRows);
       if (!rows.length) {
         const empty = document.createElement('div');
         empty.className = 'card meta-muted';
@@ -251,5 +354,14 @@ export function render({ navigate, chrome }) {
   chrome?.setTopbar(head);
   screen.append(divider, list);
   loadList();
+
+  screen.cleanup = () => {
+    closeHeadMenu();
+    document.removeEventListener('click', onOutsideClick);
+    document.removeEventListener('keydown', onMenuKeydown);
+    window.removeEventListener('resize', onMenuViewportChange);
+    window.removeEventListener('scroll', onMenuViewportChange, true);
+  };
+
   return screen;
 }

shine-UI/js/pages/notifications-view.js

@@ -1,32 +1,304 @@
 import { renderHeader } from '../components/header.js';
-import { state } from '../state.js';
+import { renderUserAvatar } from '../components/avatar-image.js';
+import { authService, state } from '../state.js';
+import { loadProfileSnapshot } from '../services/user-profile-params.js';
+import { makeProfileRoute, makeShineMessageRoute } from '../services/shine-routes.js';
+
+const CONNECTION_CLOSE_FRIEND = 10;
+const profileSnapshotCache = new Map();
+const profileSnapshotPending = new Map();
+
+function connectionTypeLabel(typeCode) {
+  switch (Number(typeCode)) {
+    case CONNECTION_CLOSE_FRIEND:
+      return 'близкие друзья';
+    default:
+      return 'новую связь';
+  }
+}
 
 export const pageMeta = { id: 'notifications-view', title: 'Уведомления' };
 
-function renderList(container) {
-  const active = state.notificationsTab;
-  container.innerHTML = '';
-  const card = document.createElement('article');
-  card.className = 'card stack';
-
-  const title = document.createElement('strong');
-  title.textContent = active === 'events' ? 'События в разработке' : 'Ответы в разработке';
-
-  const description = document.createElement('p');
-  description.className = 'meta-muted';
-  description.textContent = active === 'events'
-    ? 'Здесь будут отображаться события: кто подписался на вас, куда вас добавили, кто поставил лайк и другие действия.'
-    : 'Здесь будут отображаться ответы и комментарии на ваши сообщения в публичных каналах.';
-
-  const note = document.createElement('p');
-  note.className = 'meta-muted';
-  note.textContent = 'Раздел находится в разработке. Функционал будет добавлен в следующих обновлениях.';
-
-  card.append(title, description, note);
-  container.append(card);
+function normalizeItem(item) {
+  return {
+    kind: String(item?.kind || ''),
+    createdAtMs: Number(item?.createdAtMs || 0),
+    sourceLogin: String(item?.sourceLogin || ''),
+    sourceBlockchainName: String(item?.sourceBlockchainName || ''),
+    sourceBlockNumber: Number(item?.sourceBlockNumber || 0),
+    sourceBlockHash: String(item?.sourceBlockHash || ''),
+    sourceMsgSubType: item?.sourceMsgSubType == null ? null : Number(item.sourceMsgSubType),
+    sourceText: String(item?.sourceText || ''),
+    connectionTypeCode: item?.connectionTypeCode == null ? null : Number(item.connectionTypeCode),
+    targetLogin: String(item?.targetLogin || ''),
+    targetBlockchainName: String(item?.targetBlockchainName || ''),
+    targetBlockNumber: item?.targetBlockNumber == null ? null : Number(item.targetBlockNumber),
+    targetBlockHash: String(item?.targetBlockHash || ''),
+    profile: null,
+    engagement: null,
+  };
 }
 
-export function render({ chrome } = {}) {
+function formatRelativeTime(value) {
+  const ts = Number(value || 0);
+  if (!Number.isFinite(ts) || ts <= 0) return '';
+
+  const diffMs = Math.max(0, Date.now() - ts);
+  const minute = 60 * 1000;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  const week = 7 * day;
+
+  if (diffMs < minute) return 'сейчас';
+  if (diffMs < hour) return `${Math.max(1, Math.floor(diffMs / minute))} мин.`;
+  if (diffMs < day) return `${Math.max(1, Math.floor(diffMs / hour))} ч.`;
+  if (diffMs < week) return `${Math.max(1, Math.floor(diffMs / day))} дн.`;
+  return `${Math.max(1, Math.floor(diffMs / week))} нед.`;
+}
+
+function profileField(snapshot, key) {
+  const row = (Array.isArray(snapshot?.fields) ? snapshot.fields : [])
+    .find((field) => String(field?.key || '') === key);
+  return String(row?.value || '').trim();
+}
+
+async function loadCachedProfileSnapshot(login) {
+  const cleanLogin = String(login || '').trim();
+  if (!cleanLogin) return null;
+  const key = cleanLogin.toLowerCase();
+  if (profileSnapshotCache.has(key)) return profileSnapshotCache.get(key);
+  if (profileSnapshotPending.has(key)) return profileSnapshotPending.get(key);
+
+  const pending = loadProfileSnapshot(cleanLogin)
+    .then((snapshot) => {
+      profileSnapshotCache.set(key, snapshot || null);
+      profileSnapshotPending.delete(key);
+      return snapshot || null;
+    })
+    .catch(() => {
+      profileSnapshotCache.set(key, null);
+      profileSnapshotPending.delete(key);
+      return null;
+    });
+
+  profileSnapshotPending.set(key, pending);
+  return pending;
+}
+
+function normalizeEngagement(source) {
+  if (!source || typeof source !== 'object') return null;
+  const likesCount = Math.max(0, Number(source.likesCount || 0));
+  const repliesCount = Math.max(0, Number(source.repliesCount || 0));
+  const ratingsCount = Math.max(0, Number(source.ratingsCount || 0));
+  const repostsCount = Math.max(0, Number(source.repostsCount ?? source.repostCount ?? 0));
+  const sharesCount = Math.max(0, Number(source.sharesCount ?? source.shareCount ?? 0));
+
+  const result = {
+    likesCount: Number.isFinite(likesCount) ? likesCount : 0,
+    repliesCount: Number.isFinite(repliesCount) ? repliesCount : 0,
+    ratingsCount: Number.isFinite(ratingsCount) ? ratingsCount : 0,
+    repostsCount: Number.isFinite(repostsCount) ? repostsCount : 0,
+    sharesCount: Number.isFinite(sharesCount) ? sharesCount : 0,
+  };
+
+  return Object.values(result).some((count) => count > 0) ? result : null;
+}
+
+async function loadSourceEngagement(item) {
+  const blockchainName = String(item?.sourceBlockchainName || '').trim();
+  const blockNumber = Number(item?.sourceBlockNumber);
+  const blockHash = String(item?.sourceBlockHash || '').trim();
+  if (!blockchainName || !Number.isFinite(blockNumber) || blockNumber < 0 || !blockHash) return null;
+
+  try {
+    const payload = await authService.getMessageThread(
+      { blockchainName, blockNumber, blockHash },
+      0,
+      0,
+      1,
+      String(state.session.login || '').trim(),
+    );
+    return normalizeEngagement(payload?.focus);
+  } catch {
+    return null;
+  }
+}
+
+async function enrichItem(item, activeTab) {
+  const [profile, engagement] = await Promise.all([
+    loadCachedProfileSnapshot(item.sourceLogin),
+    activeTab === 'replies' ? loadSourceEngagement(item) : Promise.resolve(null),
+  ]);
+  return { ...item, profile, engagement };
+}
+
+function renderEmpty(activeTab) {
+  const card = document.createElement('article');
+  card.className = 'card stack';
+  const title = document.createElement('strong');
+  title.textContent = activeTab === 'events' ? 'Пока нет событий' : 'Пока нет ответов';
+  const text = document.createElement('p');
+  text.className = 'meta-muted';
+  text.textContent = activeTab === 'events'
+    ? 'Когда кто-то добавит новую связь с вами, событие появится здесь.'
+    : 'Когда кто-то ответит на ваше сообщение в канале или треде, ответ появится здесь.';
+  card.append(title, text);
+  return card;
+}
+
+function renderIdentity(item) {
+  const profile = item.profile;
+  const firstName = profileField(profile, 'first_name');
+  const lastName = profileField(profile, 'last_name');
+  const fullName = [firstName, lastName].filter(Boolean).join(' ') || item.sourceLogin || 'Пользователь';
+  const avatar = profile?.avatar?.txId
+    ? {
+      ar: String(profile.avatar.txId || '').trim(),
+      sha256Hex: String(profile.avatar.sha256Hex || '').trim().toLowerCase(),
+    }
+    : null;
+
+  const header = document.createElement('div');
+  header.className = 'notification-identity';
+  header.append(renderUserAvatar({
+    login: item.sourceLogin || 'unknown',
+    firstName,
+    lastName,
+    avatar,
+    size: 'small',
+    className: 'notification-avatar',
+  }));
+
+  const text = document.createElement('div');
+  text.className = 'notification-identity-text';
+
+  const primary = document.createElement('div');
+  primary.className = 'notification-identity-primary';
+  const name = document.createElement('strong');
+  name.className = 'notification-person-name';
+  name.textContent = fullName;
+  primary.append(name);
+
+  const login = String(item.sourceLogin || '').trim();
+  if (login) {
+    const loginEl = document.createElement('span');
+    loginEl.className = 'notification-login';
+    loginEl.textContent = `@${login}`;
+    primary.append(loginEl);
+  }
+
+  const relative = formatRelativeTime(item.createdAtMs);
+  if (relative) {
+    const separator = document.createElement('span');
+    separator.className = 'notification-time-separator';
+    separator.textContent = '·';
+    const time = document.createElement('span');
+    time.className = 'notification-time';
+    time.textContent = relative;
+    primary.append(separator, time);
+  }
+
+  text.append(primary);
+  header.append(text);
+  return header;
+}
+
+function renderEngagement(engagement) {
+  if (!engagement) return null;
+
+  const stats = [
+    { key: 'likesCount', icon: '♥', label: 'Лайки' },
+    { key: 'repliesCount', icon: '💬', label: 'Ответы' },
+    { key: 'ratingsCount', icon: '★', label: 'Оценки' },
+    { key: 'repostsCount', icon: '↻', label: 'Репосты' },
+    { key: 'sharesCount', icon: '↗', label: 'Отправки' },
+  ].filter(({ key }) => Number(engagement[key] || 0) > 0);
+
+  if (!stats.length) return null;
+
+  const row = document.createElement('div');
+  row.className = 'notification-engagement';
+  stats.forEach(({ key, icon, label }) => {
+    const stat = document.createElement('span');
+    stat.className = 'notification-engagement-item';
+    stat.title = label;
+
+    const iconEl = document.createElement('span');
+    iconEl.className = 'notification-engagement-icon';
+    iconEl.setAttribute('aria-hidden', 'true');
+    iconEl.textContent = icon;
+
+    const countEl = document.createElement('span');
+    countEl.className = 'notification-engagement-count';
+    countEl.textContent = String(engagement[key]);
+    stat.append(iconEl, countEl);
+    row.append(stat);
+  });
+
+  return row;
+}
+
+function notificationRoute(item, activeTab) {
+  if (activeTab === 'events') {
+    const login = String(item?.sourceLogin || '').trim();
+    return login ? makeProfileRoute(login) : '';
+  }
+
+  const blockchainName = String(item?.sourceBlockchainName || '').trim();
+  const blockNumber = Number(item?.sourceBlockNumber);
+  if (!blockchainName || !Number.isFinite(blockNumber) || blockNumber < 0) return '';
+
+  return makeShineMessageRoute({
+    messageBlockchainName: blockchainName,
+    messageBlockNumber: blockNumber,
+  });
+}
+
+function bindNotificationNavigation(row, routePath, navigate) {
+  if (!routePath || typeof navigate !== 'function') return;
+
+  row.classList.add('notification-card--clickable');
+  row.tabIndex = 0;
+  row.setAttribute('role', 'link');
+
+  const open = () => navigate(routePath);
+  row.addEventListener('click', open);
+  row.addEventListener('keydown', (event) => {
+    if (event.key !== 'Enter' && event.key !== ' ') return;
+    event.preventDefault();
+    open();
+  });
+}
+
+function renderItem(item, activeTab, navigate) {
+  const row = document.createElement('article');
+  row.className = 'card stack notification-card';
+  bindNotificationNavigation(row, notificationRoute(item, activeTab), navigate);
+  row.append(renderIdentity(item));
+
+  const action = document.createElement('p');
+  action.className = 'notification-action';
+  if (activeTab === 'events') {
+    action.textContent = `Добавил(а) вас в ${connectionTypeLabel(item.connectionTypeCode)}.`;
+  } else {
+    action.textContent = 'Ответил(а) на ваше сообщение.';
+  }
+  row.append(action);
+
+  if (activeTab === 'replies') {
+    const body = document.createElement('p');
+    body.className = 'notification-content';
+    body.textContent = item.sourceText || 'Ответ без текста.';
+    row.append(body);
+
+    const engagement = renderEngagement(item.engagement);
+    if (engagement) row.append(engagement);
+  }
+
+  return row;
+}
+
+export function render({ navigate, chrome } = {}) {
   const screen = document.createElement('section');
   screen.className = 'stack notifications-screen';
   chrome?.setTopbar(renderHeader({ title: 'Уведомления' }));
@@ -40,17 +312,53 @@ export function render({ chrome } = {}) {
 
   const list = document.createElement('div');
   list.className = 'stack notifications-list';
-  renderList(list);
+
+  let requestSeq = 0;
+
+  async function load() {
+    const seq = ++requestSeq;
+    const activeTab = state.notificationsTab;
+    list.replaceChildren(renderEmpty(activeTab));
+
+    try {
+      const payload = await authService.getNotifications(50);
+      if (seq !== requestSeq) return;
+      const baseItems = (activeTab === 'events' ? payload.events : payload.replies)
+        .map(normalizeItem);
+      if (!baseItems.length) {
+        list.replaceChildren(renderEmpty(activeTab));
+        return;
+      }
+
+      const items = await Promise.all(baseItems.map((item) => enrichItem(item, activeTab)));
+      if (seq !== requestSeq) return;
+      list.replaceChildren(...items.map((item) => renderItem(item, activeTab, navigate)));
+    } catch (error) {
+      if (seq !== requestSeq) return;
+      const card = document.createElement('article');
+      card.className = 'card stack';
+      const title = document.createElement('strong');
+      title.textContent = 'Не удалось загрузить уведомления';
+      const text = document.createElement('p');
+      text.className = 'meta-muted';
+      text.textContent = error?.message || 'Ошибка запроса к серверу';
+      card.append(title, text);
+      list.replaceChildren(card);
+    }
+  }
 
   tabs.querySelectorAll('.tab-btn').forEach((btn) => {
     btn.addEventListener('click', () => {
-      state.notificationsTab = btn.dataset.tab;
+      const nextTab = String(btn.dataset.tab || 'replies');
+      if (state.notificationsTab === nextTab) return;
+      state.notificationsTab = nextTab;
       tabs.querySelectorAll('.tab-btn').forEach((node) => node.classList.remove('active'));
       btn.classList.add('active');
-      renderList(list);
+      void load();
     });
   });
 
   screen.append(tabs, list);
+  void load();
   return screen;
 }

shine-UI/js/services/auth-service.js

@@ -153,6 +153,10 @@ function makeClientPlatform() {
   return 'Web';
 }
 
+function escapeUserSettingPart(value = '') {
+  return String(value ?? '').replace(/\\/g, '\\\\').replace(/\|/g, '\\|');
+}
+
 function hexToBytes(hex) {
   const clean = String(hex || '').trim().toLowerCase();
   if (!clean || clean.length % 2 !== 0) throw new Error('Некорректный hex');
@@ -2858,6 +2862,14 @@ export class AuthService {
     return response.payload || {};
   }
 
+  async getNotifications(limit = 50) {
+    const payload = {};
+    if (Number.isFinite(Number(limit))) payload.limit = Math.max(1, Math.min(200, Number(limit)));
+    const response = await this.ws.request('GetNotifications', payload);
+    if (response.status !== 200) throw opError('GetNotifications', response);
+    return response.payload || {};
+  }
+
   async getUserConnectionsGraph(login) {
     const response = await this.ws.request('GetUserConnectionsGraph', { login });
     if (response.status !== 200) throw opError('GetUserConnectionsGraph', response);
@@ -2898,6 +2910,59 @@ export class AuthService {
     return response.payload || {};
   }
 
+  async upsertUserSetting({
+    login,
+    settingType,
+    settingKey,
+    timeMs,
+    valueText = '',
+    valueNum = 0,
+    storagePwd,
+    syncDelivery = false,
+  }) {
+    const cleanLogin = String(login || '').trim();
+    const cleanSettingKey = String(settingKey || '').trim();
+    const cleanValueText = String(valueText ?? '');
+    const cleanTimeMs = Number(timeMs);
+    const cleanSettingType = Number(settingType);
+    const cleanValueNum = Number(valueNum ?? 0);
+    if (!cleanLogin || !cleanSettingKey) throw new Error('Не переданы login/settingKey');
+    if (!Number.isFinite(cleanTimeMs) || cleanTimeMs <= 0) throw new Error('Не передан корректный timeMs');
+    if (!Number.isFinite(cleanSettingType)) throw new Error('Не передан корректный settingType');
+    if (!storagePwd) throw new Error('Не передан storagePwd для подписи UpsertUserSetting.');
+
+    const secrets = await loadEncryptedUserSecrets(cleanLogin, storagePwd);
+    const clientPrivPkcs8 = String(secrets?.clientKey || '').trim();
+    if (!clientPrivPkcs8) throw new Error('Не найден приватный clientKey');
+    const privateKey = await importPkcs8Ed25519(clientPrivPkcs8);
+    const clientKey = await publicKeyB64FromPkcs8Ed25519(clientPrivPkcs8);
+
+    const preimage = [
+      'SHiNe/UserSettings:',
+      escapeUserSettingPart(cleanLogin),
+      String(cleanSettingType),
+      escapeUserSettingPart(cleanSettingKey),
+      String(Math.trunc(cleanTimeMs)),
+      escapeUserSettingPart(cleanValueText),
+      String(Math.trunc(cleanValueNum)),
+    ].join('|');
+    const signature = await signBase64(privateKey, preimage);
+
+    const response = await this.ws.request('UpsertUserSetting', {
+      login: cleanLogin,
+      setting_type: Math.trunc(cleanSettingType),
+      setting_key: cleanSettingKey,
+      time_ms: Math.trunc(cleanTimeMs),
+      value_text: cleanValueText,
+      value_num: Math.trunc(cleanValueNum),
+      client_key: clientKey,
+      signature,
+      sync_delivery: !!syncDelivery,
+    });
+    if (response.status !== 200) throw opError('UpsertUserSetting', response);
+    return response.payload || {};
+  }
+
   async getTestFreeAvatarQuota() {
     const response = await this.ws.request('TestGetFreeAvatarQuota', {});
     if (response.status !== 200) throw opError('TestGetFreeAvatarQuota', response);

shine-UI/styles/components.css

@@ -6268,6 +6268,37 @@ html, body { overflow-x: hidden; }
   gap: 12px;
 }
 
+.dm-chat-screen {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  gap: 12px;
+}
+
+.dm-chat-screen > .dm-chat-wrap {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+}
+
+.dm-chat-composer {
+  position: sticky;
+  bottom: 0;
+  z-index: 12;
+  flex: 0 0 auto;
+}
+
+.screen-content:has(> .dm-chat-screen) {
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.screen-content:has(> .dm-chat-screen) > .dm-chat-screen {
+  flex: 1 1 auto;
+  min-height: 0;
+}
+
 .screen-content:has(> .dm-screen) {
   scrollbar-width: none;
   -ms-overflow-style: none;
@@ -6282,27 +6313,14 @@ html, body { overflow-x: hidden; }
 .screen-content:has(> .dm-chat-screen) {
   padding-top: 0;
   padding-bottom: 0;
-  scrollbar-width: thin;
-  scrollbar-color: rgba(212, 175, 55, 0.65) rgba(255, 255, 255, 0.06);
+  scrollbar-width: none;
+  -ms-overflow-style: none;
 }
 
 .screen-content:has(> .dm-chat-screen)::-webkit-scrollbar {
-  width: 4px;
-  height: 4px;
-  display: block;
-}
-
-.screen-content:has(> .dm-chat-screen)::-webkit-scrollbar-track {
-  background: rgba(255, 255, 255, 0.04);
-}
-
-.screen-content:has(> .dm-chat-screen)::-webkit-scrollbar-thumb {
-  background: rgba(212, 175, 55, 0.7);
-  border-radius: 999px;
-}
-
-.screen-content:has(> .dm-chat-screen)::-webkit-scrollbar-thumb:hover {
-  background: rgba(240, 198, 76, 0.9);
+  width: 0;
+  height: 0;
+  display: none;
 }
 
 .dm-messages-log {
@@ -6401,11 +6419,10 @@ html, body { overflow-x: hidden; }
   gap: 10px;
   grid-template-columns: minmax(0, 1fr) auto;
   align-items: end;
-  position: sticky;
-  bottom: 0;
+  position: relative;
   z-index: 10;
-  margin-inline: -14px;
-  padding: 10px 12px calc(10px + env(safe-area-inset-bottom));
+  margin-inline: 0;
+  padding: 10px 0;
   border-top: 1px solid rgba(212, 175, 55, 0.22);
   background: rgba(8, 12, 20, 0.9);
   backdrop-filter: blur(12px);
@@ -7900,3 +7917,227 @@ html, body { overflow-x: hidden; }
   color: #D4AF37;
   text-shadow: 0 0 10px rgba(212, 175, 55, 0.6);
 }
+
+/* Contacts header overflow menu — vertical ellipsis + glass dropdown. */
+.dm-head-menu-wrap {
+  position: relative;
+  justify-self: end;
+  display: grid;
+  place-items: center;
+  z-index: 40;
+}
+.dm-head-menu-btn {
+  width: 46px;
+  height: 46px;
+  padding: 0;
+  border: 0;
+  border-radius: 16px;
+  display: grid;
+  place-items: center;
+  color: #FFD98A;
+  background: transparent;
+  cursor: pointer;
+  transition: background 160ms ease, box-shadow 160ms ease, transform 120ms ease;
+}
+.dm-head-menu-btn:active { transform: scale(0.94); }
+.dm-head-menu-wrap.is-open .dm-head-menu-btn,
+.dm-head-menu-btn:focus-visible {
+  outline: none;
+  background: rgba(240, 184, 46, 0.08);
+  box-shadow: inset 0 0 0 1px rgba(240, 184, 46, 0.24), 0 0 18px rgba(240, 184, 46, 0.12);
+}
+.dm-head-menu-dots {
+  width: 6px;
+  height: 24px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 3.5px;
+}
+.dm-head-menu-dots i {
+  display: block;
+  width: 4px;
+  height: 4px;
+  border-radius: 50%;
+  background: currentColor;
+  box-shadow: 0 0 7px rgba(240, 184, 46, 0.45);
+}
+.dm-head-menu {
+  position: absolute;
+  top: calc(100% + 7px);
+  right: 0;
+  width: max-content;
+  min-width: 190px;
+  padding: 6px;
+  border: 1px solid rgba(240, 184, 46, 0.26);
+  border-radius: 15px;
+  background: linear-gradient(155deg, rgba(22, 24, 31, 0.97), rgba(10, 12, 18, 0.97));
+  box-shadow: 0 16px 38px rgba(0, 0, 0, 0.42), 0 0 20px rgba(240, 184, 46, 0.08), inset 0 1px 0 rgba(255, 255, 255, 0.04);
+  backdrop-filter: blur(18px);
+  -webkit-backdrop-filter: blur(18px);
+  transform-origin: top right;
+  animation: dm-head-menu-in 140ms ease-out both;
+}
+.dm-head-menu[hidden] { display: none; }
+.dm-head-menu::before {
+  content: '';
+  position: absolute;
+  top: -5px;
+  right: 18px;
+  width: 9px;
+  height: 9px;
+  transform: rotate(45deg);
+  border-left: 1px solid rgba(240, 184, 46, 0.22);
+  border-top: 1px solid rgba(240, 184, 46, 0.22);
+  background: rgba(19, 21, 28, 0.98);
+}
+.dm-head-menu-item {
+  position: relative;
+  z-index: 1;
+  width: 100%;
+  min-height: 44px;
+  padding: 0 12px;
+  border: 0;
+  border-radius: 10px;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  color: #FCEAC0;
+  background: transparent;
+  font: inherit;
+  font-size: 14px;
+  font-weight: 600;
+  text-align: left;
+  white-space: nowrap;
+  cursor: pointer;
+}
+.dm-head-menu-item svg {
+  width: 19px;
+  height: 19px;
+  flex: 0 0 auto;
+  color: #E7B83D;
+  filter: drop-shadow(0 0 5px rgba(240, 184, 46, 0.22));
+}
+.dm-head-menu-item:hover,
+.dm-head-menu-item:focus-visible,
+.dm-head-menu-item:active {
+  outline: none;
+  background: rgba(240, 184, 46, 0.09);
+}
+@keyframes dm-head-menu-in {
+  from { opacity: 0; transform: translateY(-5px) scale(0.97); }
+  to { opacity: 1; transform: translateY(0) scale(1); }
+}
+@media (prefers-reduced-motion: reduce) {
+  .dm-head-menu { animation: none; }
+  .dm-head-menu-btn { transition: none; }
+}
+
+/* Contacts overflow menu body portal: avoids topbar overflow hit-testing on desktop/Android. */
+.dm-head-menu--portal {
+  position: fixed;
+  right: auto;
+  z-index: 10000;
+  pointer-events: auto;
+  isolation: isolate;
+}
+
+/* ===== Notifications: social event cards ===== */
+.notifications-screen .notification-card {
+  gap: 10px;
+}
+
+.notification-identity {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-width: 0;
+}
+
+.notification-avatar {
+  flex: 0 0 auto;
+}
+
+.notification-identity-text {
+  min-width: 0;
+  flex: 1 1 auto;
+}
+
+.notification-identity-primary {
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  min-width: 0;
+  flex-wrap: wrap;
+}
+
+.notification-person-name {
+  color: rgba(255, 255, 255, 0.96);
+  font-weight: 700;
+  overflow-wrap: anywhere;
+}
+
+.notification-login,
+.notification-time-separator,
+.notification-time {
+  color: rgba(255, 255, 255, 0.5);
+  font-size: 12px;
+}
+
+.notification-action,
+.notification-content {
+  margin: 0;
+}
+
+.notification-action {
+  color: rgba(255, 255, 255, 0.66);
+  font-size: 13px;
+}
+
+.notification-content {
+  color: rgba(255, 255, 255, 0.94);
+  font-size: 15px;
+  line-height: 1.45;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+.notification-engagement {
+  display: flex;
+  align-items: center;
+  gap: 18px;
+  flex-wrap: wrap;
+  padding-top: 2px;
+  color: rgba(255, 255, 255, 0.58);
+}
+
+.notification-engagement-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  min-width: 24px;
+  font-size: 12px;
+  line-height: 1;
+}
+
+.notification-engagement-icon {
+  font-size: 15px;
+}
+
+
+.notifications-screen .notification-card--clickable {
+  cursor: pointer;
+  transition: transform 120ms ease, border-color 120ms ease, background-color 120ms ease;
+}
+
+.notifications-screen .notification-card--clickable:hover,
+.notifications-screen .notification-card--clickable:focus-visible {
+  border-color: rgba(255, 255, 255, 0.2);
+  background: rgba(255, 255, 255, 0.055);
+  outline: none;
+}
+
+.notifications-screen .notification-card--clickable:active {
+  transform: scale(0.99);
+}

shine-UI/styles/layout.css

@@ -2,7 +2,7 @@ body {
   display: flex;
   justify-content: center;
   background: #05070A;
-  min-height: 100vh;
+  min-height: 100dvh;
   position: relative;
   overflow: hidden;
 }
@@ -22,12 +22,11 @@ body::before {
 }
 
 .app-shell {
-  width: min(100vw, 430px);
-  height: 100vh;
-  height: 100svh;
+  width: min(var(--app-viewport-width, 100vw), 430px);
+  height: var(--app-viewport-height, 100vh);
   position: fixed;
-  top: 0;
-  left: 50%;
+  top: var(--app-viewport-offset-top, 0px);
+  left: calc(50% + var(--app-viewport-offset-left, 0px) / 2);
   transform: translateX(-50%);
   --call-minimized-bar-height: 0px;
   --topbar-height: 0px;
@@ -94,10 +93,11 @@ body::before {
 
 .composer-slot {
   position: absolute;
-  left: 0;
-  right: 0;
+  left: 50%;
+  width: min(var(--app-viewport-width, 100vw), 430px);
+  transform: translateX(-50%);
   bottom: calc(var(--toolbar-height, 78px) + env(safe-area-inset-bottom));
-  padding: 0 12px 8px;
+  padding: 0 12px;
   pointer-events: none;
 }
 
@@ -115,20 +115,42 @@ body::before {
   transition: opacity 0.18s ease, transform 0.18s ease;
 }
 
-body.chat-keyboard-open .screen-content {
-  bottom: calc(var(--composer-height, 0px) + max(var(--toolbar-height, 78px), var(--keyboard-offset, 0px)));
-  padding-bottom: calc(14px + env(safe-area-inset-bottom));
-}
-
-body.chat-keyboard-open .composer-slot {
-  bottom: max(var(--toolbar-height, 78px), var(--keyboard-offset, 0px));
-  padding-bottom: calc(8px + env(safe-area-inset-bottom));
-}
-
-body.chat-keyboard-open .toolbar-slot {
-  opacity: 1;
-  pointer-events: auto;
+body.chat-topbar-overlay .topbar-slot {
+  position: fixed;
+  top: var(--call-minimized-bar-height, 0px);
+  left: 0;
+  right: 0;
+  width: min(100vw, 430px);
+  margin: 0 auto;
   transform: none;
+  padding: 0 12px;
+}
+
+body.chat-topbar-overlay .screen-content {
+  top: calc(var(--call-minimized-bar-height, 0px) + var(--topbar-height, 0px));
+  bottom: calc(var(--toolbar-height, 78px) + var(--composer-height, 0px));
+}
+
+body.chat-topbar-overlay .composer-slot {
+  position: absolute;
+  left: 50%;
+  width: min(var(--app-viewport-width, 100vw), 430px);
+  bottom: calc(var(--toolbar-height, 78px) + env(safe-area-inset-bottom));
+}
+
+/* При открытой клавиатуре toolbar остаётся на физическом дне экрана и
+   перекрывается клавиатурой. Composer прижимается ровно к верхней границе
+   visualViewport, а область сообщений заканчивается прямо над composer. */
+.app-shell.keyboard-open .toolbar-slot {
+  bottom: 0;
+}
+
+body.chat-topbar-overlay .app-shell.keyboard-open .composer-slot {
+  bottom: var(--keyboard-offset, 0px);
+}
+
+body.chat-topbar-overlay .app-shell.keyboard-open .screen-content {
+  bottom: calc(var(--keyboard-offset, 0px) + var(--composer-height, 0px));
 }
 
 .connection-retry-banner {
@@ -177,3 +199,12 @@ body.chat-keyboard-open .toolbar-slot {
     border-radius: 24px;
   }
 }
+
+/* Android keyboard: composer touches the keyboard edge; only the composer moves. */
+body.chat-topbar-overlay .app-shell.keyboard-open .composer-slot {
+  padding-bottom: 0;
+}
+
+body.chat-topbar-overlay .app-shell.keyboard-open .composer-slot .dm-chat-input {
+  padding-bottom: 0;
+}