${item.name}
+ ${item.notInContacts ? 'не в контактах' : ''}
${item.lastMessage}
@@ -46,32 +47,57 @@ export function render({ navigate }) {
try {
const relations = await loadCurrentRelations();
const contacts = relations.outContacts || [];
+ setContacts(contacts);
list.innerHTML = '';
-
- if (!contacts.length) {
- const empty = document.createElement('div');
- empty.className = 'card meta-muted';
- empty.textContent = 'Ваш список контактов пока пуст';
- list.append(empty);
- status.className = 'status-line is-available';
- status.textContent = 'Нет контактов.';
- return;
- }
-
- const rows = contacts.map((login) => {
+ const contactRows = contacts.map((login) => {
const preview = directMessages.find((item) => item.id.toLowerCase() === login.toLowerCase());
const chat = getChatMessages(login);
const lastChat = chat[chat.length - 1];
+ const unread = chat.filter((m) => m?.from === 'in' && m?.unread).length;
return {
id: login,
initials: (login[0] || '?').toUpperCase(),
name: preview?.name || login,
lastMessage: lastChat?.text || preview?.lastMessage || 'Диалог пока пуст.',
time: preview?.time || '—',
- unread: Number(preview?.unread || 0),
+ unread,
+ notInContacts: false,
};
});
+ const allChatIds = Object.keys(state.chats || {})
+ .filter((id) => id && id.toLowerCase() !== String(state.session.login || '').toLowerCase())
+ .filter((id) => (getChatMessages(id) || []).length > 0);
+
+ const contactKeys = new Set(contacts.map((x) => String(x || '').toLowerCase()));
+ const extraRows = allChatIds
+ .filter((login) => !contactKeys.has(String(login || '').toLowerCase()))
+ .map((login) => {
+ const chat = getChatMessages(login);
+ const lastChat = chat[chat.length - 1];
+ const unread = chat.filter((m) => m?.from === 'in' && m?.unread).length;
+ return {
+ id: login,
+ initials: (login[0] || '?').toUpperCase(),
+ name: login,
+ lastMessage: lastChat?.text || 'Диалог пока пуст.',
+ time: 'сейчас',
+ unread,
+ notInContacts: true,
+ };
+ });
+
+ const rows = [...contactRows, ...extraRows];
+ if (!rows.length) {
+ const empty = document.createElement('div');
+ empty.className = 'card meta-muted';
+ empty.textContent = 'Пока нет ни контактов, ни сообщений';
+ list.append(empty);
+ status.className = 'status-line is-available';
+ status.textContent = 'Нет диалогов.';
+ return;
+ }
+
rows.forEach((item) => list.append(renderRow(item)));
status.className = 'status-line is-available';
status.textContent = `Загружено диалогов: ${rows.length}`;
diff --git a/shine-UI/js/services/auth-service.js b/shine-UI/js/services/auth-service.js
index bccd3c5..48d4930 100644
--- a/shine-UI/js/services/auth-service.js
+++ b/shine-UI/js/services/auth-service.js
@@ -200,6 +200,114 @@ function uint8Bytes(value) {
return new Uint8Array([Number(value) & 0xff]);
}
+const DM2_PREFIX = utf8Bytes('SHiNE_dm2');
+const DM2_TYPE_INCOMING = 1;
+const DM2_TYPE_OUTGOING_COPY = 2;
+const DM2_TYPE_READ_INCOMING = 3;
+const DM2_TYPE_READ_OUTGOING_COPY = 4;
+
+function ensureAsciiBytes(value, field, min = 1, max = 60) {
+ const text = String(value || '').trim();
+ const bytes = utf8Bytes(text);
+ if (bytes.length < min || bytes.length > max) {
+ throw new Error(`${field} должен быть ${min}..${max} ASCII-символов`);
+ }
+ for (let i = 0; i < bytes.length; i += 1) {
+ const code = bytes[i];
+ if (code < 0x20 || code > 0x7e) throw new Error(`${field} должен быть ASCII`);
+ }
+ return bytes;
+}
+
+function dm2BaseKey({ toLogin, fromLogin, timeMs, nonce }) {
+ return `${fromLogin}|${toLogin}|${Number(timeMs)}|${Number(nonce)}`;
+}
+
+function dm2MessageKey({ toLogin, fromLogin, timeMs, nonce, messageType }) {
+ return `${dm2BaseKey({ toLogin, fromLogin, timeMs, nonce })}|${Number(messageType)}`;
+}
+
+function buildReadReceiptPayloadBytes({ refToLogin, refFromLogin, refTimeMs, refNonce, refType }) {
+ const toBytes = ensureAsciiBytes(refToLogin, 'receipt.refToLogin');
+ const fromBytes = ensureAsciiBytes(refFromLogin, 'receipt.refFromLogin');
+ return concatBytes(
+ uint8Bytes(toBytes.length), toBytes,
+ uint8Bytes(fromBytes.length), fromBytes,
+ uint64Bytes(refTimeMs),
+ uint32Bytes(refNonce),
+ uint16Bytes(refType),
+ );
+}
+
+function parseSignedMessageBlockBytes(bytes) {
+ if (!(bytes instanceof Uint8Array)) throw new Error('Expected Uint8Array');
+ let o = 0;
+ const read = (n) => {
+ if (o + n > bytes.length) throw new Error('BAD_LEN');
+ const out = bytes.slice(o, o + n);
+ o += n;
+ return out;
+ };
+ const readU8 = () => read(1)[0];
+ const readU16 = () => {
+ const part = read(2);
+ const view = new DataView(part.buffer, part.byteOffset, 2);
+ return view.getUint16(0, false);
+ };
+ const readU32 = () => {
+ const part = read(4);
+ const view = new DataView(part.buffer, part.byteOffset, 4);
+ return view.getUint32(0, false);
+ };
+ const readU64 = () => {
+ const part = read(8);
+ const view = new DataView(part.buffer, part.byteOffset, 8);
+ return Number(view.getBigUint64(0, false));
+ };
+ const readAscii = () => {
+ const len = readU8();
+ const part = read(len);
+ const text = new TextDecoder().decode(part);
+ for (let i = 0; i < part.length; i += 1) {
+ const c = part[i];
+ if (c < 0x20 || c > 0x7e) throw new Error('BAD_ASCII');
+ }
+ return text;
+ };
+
+ const prefix = read(DM2_PREFIX.length);
+ for (let i = 0; i < DM2_PREFIX.length; i += 1) {
+ if (prefix[i] !== DM2_PREFIX[i]) throw new Error('BAD_PREFIX');
+ }
+
+ const toLogin = readAscii();
+ const fromLogin = readAscii();
+ const timeMs = readU64();
+ const nonce = readU32();
+ const messageType = readU16();
+ const payloadLen = readU16();
+ const payloadBytes = read(payloadLen);
+ const signatureBytes = read(64);
+ if (o !== bytes.length) throw new Error('BAD_LEN');
+
+ const signedBody = bytes.slice(0, bytes.length - 64);
+ const baseKey = dm2BaseKey({ toLogin, fromLogin, timeMs, nonce });
+ const messageKey = dm2MessageKey({ toLogin, fromLogin, timeMs, nonce, messageType });
+ return {
+ toLogin,
+ fromLogin,
+ timeMs,
+ nonce,
+ messageType,
+ payloadBytes,
+ signatureBytes,
+ signedBody,
+ rawBytes: bytes,
+ baseKey,
+ messageKey,
+ };
+}
+
function makeUserParamBodyBytes({ lineCode, prevLineNumber, prevLineHashHex, thisLineNumber, key, value }) {
const keyBytes = utf8Bytes(String(key || ''));
const valueBytes = utf8Bytes(String(value || ''));
@@ -1118,11 +1226,18 @@ export class AuthService {
return response.payload || {};
}
- async sendDirectMessage({ login, toLogin, text, storagePwd, targetSessionId = null, messageType = 1 }) {
+ async buildSignedDm2Block({
+ login,
+ toLogin,
+ storagePwd,
+ timeMs,
+ nonce,
+ messageType,
+ payloadBytes,
+ }) {
const cleanFromLogin = String(login || '').trim();
const cleanToLogin = String(toLogin || '').trim();
- const cleanText = String(text || '');
- if (!cleanFromLogin || !cleanToLogin || !cleanText) throw new Error('Не передан login/toLogin/text');
+ if (!cleanFromLogin || !cleanToLogin) throw new Error('Не передан login/toLogin');
if (!storagePwd) throw new Error('Не передан storagePwd для подписи');
const secrets = await loadEncryptedUserSecrets(cleanFromLogin, storagePwd);
@@ -1130,46 +1245,147 @@ export class AuthService {
if (!devicePriv) throw new Error('Не найден приватный deviceKey');
const privateKey = await importPkcs8Ed25519(devicePriv);
- const prefix = utf8Bytes('SHiNE_msg');
- const version = uint8Bytes(1);
- const toBytes = utf8Bytes(cleanToLogin);
- const fromBytes = utf8Bytes(cleanFromLogin);
- if (toBytes.length < 1 || toBytes.length > 30) throw new Error('toLogin должен быть 1..30 ASCII-символов');
- if (fromBytes.length < 1 || fromBytes.length > 30) throw new Error('fromLogin должен быть 1..30 ASCII-символов');
- if (cleanText.length > 3000) throw new Error('Слишком длинное сообщение');
-
- const mode = targetSessionId ? 1 : 0;
- const targetBytes = targetSessionId ? utf8Bytes(String(targetSessionId)) : new Uint8Array(0);
- if (mode === 1 && (targetBytes.length < 1 || targetBytes.length > 255)) {
- throw new Error('targetSessionId должен быть 1..255 символов');
+ const toBytes = ensureAsciiBytes(cleanToLogin, 'toLogin');
+ const fromBytes = ensureAsciiBytes(cleanFromLogin, 'fromLogin');
+ if (!(payloadBytes instanceof Uint8Array) || payloadBytes.length < 1 || payloadBytes.length > 4096) {
+ throw new Error('payload должен быть 1..4096 байт');
}
- const bodyBytes = utf8Bytes(cleanText);
const preimage = concatBytes(
- prefix,
- version,
+ DM2_PREFIX,
uint8Bytes(toBytes.length), toBytes,
uint8Bytes(fromBytes.length), fromBytes,
- uint64Bytes(Date.now()),
- uint32Bytes(Math.floor(Math.random() * 0x100000000)),
+ uint64Bytes(timeMs),
+ uint32Bytes(nonce),
uint16Bytes(messageType),
- uint8Bytes(mode),
- mode === 1 ? concatBytes(uint8Bytes(targetBytes.length), targetBytes) : new Uint8Array(0),
- uint16Bytes(bodyBytes.length),
- bodyBytes,
+ uint16Bytes(payloadBytes.length),
+ payloadBytes,
);
const signature = await signBytes(privateKey, preimage);
- const packet = concatBytes(preimage, signature);
- const blobB64 = bytesToBase64(packet);
+ return concatBytes(preimage, signature);
+ }
- const response = await this.ws.request('SendDirectMessage', { blobB64 });
- if (response.status !== 200) throw opError('SendDirectMessage', response);
+ parseSignedMessageBlob(blobB64) {
+ const bytes = base64ToBytes(String(blobB64 || '').trim());
+ return parseSignedMessageBlockBytes(bytes);
+ }
+
+ parseReadReceiptPayload(payloadBytes) {
+ if (!(payloadBytes instanceof Uint8Array)) throw new Error('Expected Uint8Array');
+ let o = 0;
+ const read = (n) => {
+ if (o + n > payloadBytes.length) throw new Error('BAD_RECEIPT_LEN');
+ const out = payloadBytes.slice(o, o + n);
+ o += n;
+ return out;
+ };
+ const readU8 = () => read(1)[0];
+ const readU16 = () => {
+ const part = read(2);
+ return new DataView(part.buffer, part.byteOffset, 2).getUint16(0, false);
+ };
+ const readU32 = () => {
+ const part = read(4);
+ return new DataView(part.buffer, part.byteOffset, 4).getUint32(0, false);
+ };
+ const readU64 = () => {
+ const part = read(8);
+ return Number(new DataView(part.buffer, part.byteOffset, 8).getBigUint64(0, false));
+ };
+ const readAscii = () => {
+ const len = readU8();
+ const part = read(len);
+ return new TextDecoder().decode(part);
+ };
+ const refToLogin = readAscii();
+ const refFromLogin = readAscii();
+ const refTimeMs = readU64();
+ const refNonce = readU32();
+ const refType = readU16();
+ if (o !== payloadBytes.length) throw new Error('BAD_RECEIPT_LEN');
+ return { refToLogin, refFromLogin, refTimeMs, refNonce, refType };
+ }
+
+ async sendMessagePair({ incomingBlobB64, outgoingBlobB64 }) {
+ const response = await this.ws.request('SendMessagePair', { incomingBlobB64, outgoingBlobB64 });
+ if (response.status !== 200) throw opError('SendMessagePair', response);
return response.payload || {};
}
- async ackIncomingMessage(eventId, messageId) {
- const response = await this.ws.request('AckIncomingMessage', { eventId, messageId });
- if (response.status !== 200) throw opError('AckIncomingMessage', response);
+ async sendDirectMessage({ login, toLogin, text, storagePwd }) {
+ const cleanFromLogin = String(login || '').trim();
+ const cleanToLogin = String(toLogin || '').trim();
+ const cleanText = String(text || '');
+ if (!cleanFromLogin || !cleanToLogin || !cleanText) throw new Error('Не передан login/toLogin/text');
+
+ const timeMs = Date.now();
+ const nonce = Math.floor(Math.random() * 0x100000000);
+ const incomingPayload = utf8Bytes(cleanText);
+ const outgoingPayload = utf8Bytes(cleanText);
+
+ const incomingBlock = await this.buildSignedDm2Block({
+ login: cleanFromLogin,
+ toLogin: cleanToLogin,
+ storagePwd,
+ timeMs,
+ nonce,
+ messageType: DM2_TYPE_INCOMING,
+ payloadBytes: incomingPayload,
+ });
+ const outgoingBlock = await this.buildSignedDm2Block({
+ login: cleanFromLogin,
+ toLogin: cleanToLogin,
+ storagePwd,
+ timeMs,
+ nonce,
+ messageType: DM2_TYPE_OUTGOING_COPY,
+ payloadBytes: outgoingPayload,
+ });
+
+ const payload = await this.sendMessagePair({
+ incomingBlobB64: bytesToBase64(incomingBlock),
+ outgoingBlobB64: bytesToBase64(outgoingBlock),
+ });
+ return {
+ ...payload,
+ localIncomingBlobB64: bytesToBase64(incomingBlock),
+ localOutgoingBlobB64: bytesToBase64(outgoingBlock),
+ localBaseKey: dm2BaseKey({ toLogin: cleanToLogin, fromLogin: cleanFromLogin, timeMs, nonce }),
+ };
+ }
+
+ async sendReadReceipt({ login, toLogin, storagePwd, refToLogin, refFromLogin, refTimeMs, refNonce, refType = DM2_TYPE_INCOMING }) {
+ const timeMs = Date.now();
+ const nonce = Math.floor(Math.random() * 0x100000000);
+ const payload = buildReadReceiptPayloadBytes({ refToLogin, refFromLogin, refTimeMs, refNonce, refType });
+
+ const type3 = await this.buildSignedDm2Block({
+ login,
+ toLogin,
+ storagePwd,
+ timeMs,
+ nonce,
+ messageType: DM2_TYPE_READ_INCOMING,
+ payloadBytes: payload,
+ });
+ const type4 = await this.buildSignedDm2Block({
+ login,
+ toLogin,
+ storagePwd,
+ timeMs,
+ nonce,
+ messageType: DM2_TYPE_READ_OUTGOING_COPY,
+ payloadBytes: payload,
+ });
+ return this.sendMessagePair({
+ incomingBlobB64: bytesToBase64(type3),
+ outgoingBlobB64: bytesToBase64(type4),
+ });
+ }
+
+ async ackSessionDelivery(messageKey) {
+ const response = await this.ws.request('AckSessionDelivery', { messageKey });
+ if (response.status !== 200) throw opError('AckSessionDelivery', response);
return response.payload || {};
}
diff --git a/shine-UI/js/services/message-store.js b/shine-UI/js/services/message-store.js
new file mode 100644
index 0000000..70e42ff
--- /dev/null
+++ b/shine-UI/js/services/message-store.js
@@ -0,0 +1,50 @@
+const DB_NAME = 'shine-ui-messages-v1';
+const DB_VERSION = 1;
+const STORE_MESSAGES = 'messages';
+
+function openDb() {
+ return new Promise((resolve, reject) => {
+ const request = indexedDB.open(DB_NAME, DB_VERSION);
+ request.onupgradeneeded = () => {
+ const db = request.result;
+ if (!db.objectStoreNames.contains(STORE_MESSAGES)) {
+ const store = db.createObjectStore(STORE_MESSAGES, { keyPath: 'messageKey' });
+ store.createIndex('by_chat', 'chatId', { unique: false });
+ store.createIndex('by_ts', 'ts', { unique: false });
+ }
+ };
+ request.onsuccess = () => resolve(request.result);
+ request.onerror = () => reject(request.error || new Error('IndexedDB open failed'));
+ });
+}
+
+async function withStore(mode, callback) {
+ const db = await openDb();
+ try {
+ return await new Promise((resolve, reject) => {
+ const tx = db.transaction(STORE_MESSAGES, mode);
+ const store = tx.objectStore(STORE_MESSAGES);
+ const result = callback(store, tx);
+ tx.oncomplete = () => resolve(result);
+ tx.onerror = () => reject(tx.error || new Error('IndexedDB transaction failed'));
+ tx.onabort = () => reject(tx.error || new Error('IndexedDB transaction aborted'));
+ });
+ } finally {
+ db.close();
+ }
+}
+
+export async function putStoredMessage(record) {
+ if (!record || !record.messageKey) return;
+ await withStore('readwrite', (store) => {
+ store.put(record);
+ });
+}
+
+export async function listStoredMessages() {
+ return withStore('readonly', (store) => new Promise((resolve, reject) => {
+ const req = store.getAll();
+ req.onsuccess = () => resolve(Array.isArray(req.result) ? req.result : []);
+ req.onerror = () => reject(req.error || new Error('IndexedDB getAll failed'));
+ }));
+}
diff --git a/shine-UI/js/state.js b/shine-UI/js/state.js
index e26ac67..f7301b8 100644
--- a/shine-UI/js/state.js
+++ b/shine-UI/js/state.js
@@ -1,6 +1,7 @@
import { chatMessages, wallet } from './mock-data.js';
import { AuthService } from './services/auth-service.js';
import { clearClientAuthData } from './services/key-vault.js';
+import { listStoredMessages, putStoredMessage } from './services/message-store.js';
const clone = (value) => JSON.parse(JSON.stringify(value));
const SESSION_STORAGE_KEY = 'shine-ui-current-session-v1';
@@ -130,6 +131,8 @@ function createInitialState({ withStoredSession = true } = {}) {
contacts: [],
appLog: [],
incomingDedup: {},
+ knownMessageKeys: {},
+ outgoingTempSeq: 1,
notificationsTab: 'replies',
pageLabelCollapsed: false,
session: {
@@ -199,6 +202,55 @@ export const authService = new AuthService(state.entrySettings.shineServer);
let onSessionReset = null;
let onSessionAuthorized = null;
+function persistMessageRecord(chatId, row) {
+ if (!chatId || !row?.messageKey) return;
+ void putStoredMessage({
+ messageKey: row.messageKey,
+ chatId,
+ from: row.from || 'in',
+ text: String(row.text || ''),
+ baseKey: String(row.baseKey || ''),
+ messageType: Number(row.messageType || 0),
+ rawBlobB64: String(row.rawBlobB64 || ''),
+ unread: Boolean(row.unread),
+ firstTick: Boolean(row.firstTick),
+ secondTick: Boolean(row.secondTick),
+ readReceiptSent: Boolean(row.readReceiptSent),
+ refBaseKey: String(row.refBaseKey || ''),
+ ts: Date.now(),
+ }).catch(() => {});
+}
+
+export async function hydrateMessagesFromStore() {
+ try {
+ const rows = await listStoredMessages();
+ rows
+ .sort((a, b) => Number(a?.ts || 0) - Number(b?.ts || 0))
+ .forEach((row) => {
+ const chatId = String(row?.chatId || '').trim();
+ const messageKey = String(row?.messageKey || '').trim();
+ if (!chatId || !messageKey) return;
+ if (state.knownMessageKeys[messageKey]) return;
+ state.knownMessageKeys[messageKey] = true;
+ getChatMessages(chatId).push({
+ from: row.from === 'out' ? 'out' : 'in',
+ text: String(row.text || ''),
+ messageKey,
+ baseKey: String(row.baseKey || ''),
+ messageType: Number(row.messageType || 0),
+ rawBlobB64: String(row.rawBlobB64 || ''),
+ unread: Boolean(row.unread),
+ firstTick: Boolean(row.firstTick),
+ secondTick: Boolean(row.secondTick),
+ readReceiptSent: Boolean(row.readReceiptSent),
+ refBaseKey: String(row.refBaseKey || ''),
+ });
+ });
+ } catch {
+ // ignore broken storage
+ }
+}
+
export function getChatMessages(chatId) {
if (!state.chats[chatId]) {
state.chats[chatId] = [];
@@ -209,7 +261,7 @@ export function getChatMessages(chatId) {
export function addChatMessage(chatId, text) {
const message = text.trim();
if (!message) return;
- getChatMessages(chatId).push({ from: 'out', text: message });
+ getChatMessages(chatId).push({ from: 'out', text: message, firstTick: false, secondTick: false, unread: false });
}
@@ -218,10 +270,100 @@ export function addIncomingMessage(chatId, text, messageId = '') {
if (!msg) return false;
if (messageId && state.incomingDedup[messageId]) return false;
if (messageId) state.incomingDedup[messageId] = true;
- getChatMessages(chatId).push({ from: 'in', text: msg, messageId });
+ getChatMessages(chatId).push({ from: 'in', text: msg, messageId, unread: true });
return true;
}
+export function addOutgoingPendingMessage(chatId, text) {
+ const msg = String(text || '').trim();
+ if (!msg) return null;
+ const tempId = `tmp-${Date.now()}-${state.outgoingTempSeq++}`;
+ getChatMessages(chatId).push({
+ from: 'out',
+ text: msg,
+ tempId,
+ firstTick: false,
+ secondTick: false,
+ unread: false,
+ });
+ return tempId;
+}
+
+export function markOutgoingSent(tempId, { messageKey = '', baseKey = '' } = {}) {
+ if (!tempId) return;
+ const keys = Object.keys(state.chats || {});
+ keys.forEach((chatId) => {
+ const list = getChatMessages(chatId);
+ const row = list.find((item) => item?.tempId === tempId);
+ if (!row) return;
+ row.firstTick = true;
+ row.messageKey = messageKey || row.messageKey || '';
+ row.baseKey = baseKey || row.baseKey || '';
+ if (messageKey) {
+ state.knownMessageKeys[messageKey] = true;
+ persistMessageRecord(chatId, row);
+ }
+ });
+}
+
+export function markOutgoingReadByBaseKey(baseKey) {
+ if (!baseKey) return;
+ const keys = Object.keys(state.chats || {});
+ keys.forEach((chatId) => {
+ const list = getChatMessages(chatId);
+ list.forEach((row) => {
+ if (row?.from !== 'out') return;
+ if (row.baseKey === baseKey) {
+ row.secondTick = true;
+ persistMessageRecord(chatId, row);
+ }
+ });
+ });
+}
+
+export function addSignedMessageToChat({
+ chatId,
+ messageKey,
+ baseKey = '',
+ from = 'in',
+ text = '',
+ messageType = 1,
+ unread = false,
+ rawBlobB64 = '',
+ refBaseKey = '',
+} = {}) {
+ const id = String(messageKey || '').trim();
+ if (!chatId || !id) return false;
+ if (state.knownMessageKeys[id]) return false;
+ state.knownMessageKeys[id] = true;
+
+ const row = {
+ from: from === 'out' ? 'out' : 'in',
+ text: String(text || ''),
+ messageKey: id,
+ baseKey: String(baseKey || ''),
+ messageType: Number(messageType || 0),
+ rawBlobB64: String(rawBlobB64 || ''),
+ unread: Boolean(unread),
+ refBaseKey: String(refBaseKey || ''),
+ firstTick: from === 'out',
+ secondTick: false,
+ };
+ getChatMessages(chatId).push(row);
+ persistMessageRecord(chatId, row);
+ return true;
+}
+
+export function markChatRead(chatId) {
+ const list = getChatMessages(chatId);
+ list.forEach((row) => {
+ if (row?.from === 'in') {
+ row.unread = false;
+ persistMessageRecord(chatId, row);
+ }
+ });
+}
+
export function setContacts(list) {
state.contacts = Array.isArray(list) ? [...list] : [];
}
diff --git a/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java b/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java
index 37c0f68..25888db 100644
--- a/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java
+++ b/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java
@@ -496,6 +496,56 @@ public final class DatabaseInitializer {
ON signed_direct_messages_history (to_login, created_at_ms);
""");
+ // 13) signed_messages_v2 (универсальное хранилище блоков типов 1/2/3/4)
+ st.executeUpdate("""
+ CREATE TABLE IF NOT EXISTS signed_messages_v2 (
+ message_key TEXT NOT NULL PRIMARY KEY,
+ base_key TEXT NOT NULL,
+ target_login TEXT NOT NULL,
+ from_login TEXT NOT NULL,
+ to_login TEXT NOT NULL,
+ time_ms INTEGER NOT NULL,
+ nonce INTEGER NOT NULL,
+ message_type INTEGER NOT NULL,
+ raw_block BLOB NOT NULL,
+ created_at_ms INTEGER NOT NULL,
+ source_api TEXT NOT NULL,
+ origin_session_id TEXT,
+ receipt_ref_base_key TEXT,
+ receipt_ref_type INTEGER,
+ FOREIGN KEY (from_login) REFERENCES solana_users(login),
+ FOREIGN KEY (to_login) REFERENCES solana_users(login)
+ );
+ """);
+
+ st.executeUpdate("""
+ CREATE INDEX IF NOT EXISTS idx_signed_messages_v2_target
+ ON signed_messages_v2 (target_login, time_ms, created_at_ms);
+ """);
+
+ st.executeUpdate("""
+ CREATE INDEX IF NOT EXISTS idx_signed_messages_v2_base
+ ON signed_messages_v2 (base_key, message_type);
+ """);
+
+ // 14) signed_message_session_delivery (доставка по сессиям)
+ st.executeUpdate("""
+ CREATE TABLE IF NOT EXISTS signed_message_session_delivery (
+ message_key TEXT NOT NULL,
+ session_id TEXT NOT NULL,
+ delivered INTEGER NOT NULL DEFAULT 0,
+ delivered_at_ms INTEGER,
+ created_at_ms INTEGER NOT NULL,
+ PRIMARY KEY (message_key, session_id),
+ FOREIGN KEY (message_key) REFERENCES signed_messages_v2(message_key)
+ );
+ """);
+
+ st.executeUpdate("""
+ CREATE INDEX IF NOT EXISTS idx_signed_message_delivery_session
+ ON signed_message_session_delivery (session_id, delivered);
+ """);
+
DatabaseTriggersInstaller.createAllTriggers(st);
}
}
diff --git a/shine-server-db/src/main/java/shine/db/dao/SignedMessagesV2DAO.java b/shine-server-db/src/main/java/shine/db/dao/SignedMessagesV2DAO.java
new file mode 100644
index 0000000..c0205b7
--- /dev/null
+++ b/shine-server-db/src/main/java/shine/db/dao/SignedMessagesV2DAO.java
@@ -0,0 +1,182 @@
+package shine.db.dao;
+
+import shine.db.SqliteDbController;
+import shine.db.entities.SignedMessageV2Entry;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class SignedMessagesV2DAO {
+ private static volatile SignedMessagesV2DAO instance;
+ private final SqliteDbController db = SqliteDbController.getInstance();
+
+ private SignedMessagesV2DAO() {}
+
+ public static SignedMessagesV2DAO getInstance() {
+ if (instance == null) {
+ synchronized (SignedMessagesV2DAO.class) {
+ if (instance == null) instance = new SignedMessagesV2DAO();
+ }
+ }
+ return instance;
+ }
+
+ public boolean insertIfAbsent(SignedMessageV2Entry e) throws Exception {
+ try (Connection c = db.getConnection()) {
+ String sql = """
+ INSERT OR IGNORE INTO signed_messages_v2 (
+ message_key, base_key, target_login, from_login, to_login,
+ time_ms, nonce, message_type, raw_block, created_at_ms,
+ source_api, origin_session_id, receipt_ref_base_key, receipt_ref_type
+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ """;
+ try (PreparedStatement ps = c.prepareStatement(sql)) {
+ ps.setString(1, e.getMessageKey());
+ ps.setString(2, e.getBaseKey());
+ ps.setString(3, e.getTargetLogin());
+ ps.setString(4, e.getFromLogin());
+ ps.setString(5, e.getToLogin());
+ ps.setLong(6, e.getTimeMs());
+ ps.setLong(7, e.getNonce());
+ ps.setInt(8, e.getMessageType());
+ ps.setBytes(9, e.getRawBlock());
+ ps.setLong(10, e.getCreatedAtMs());
+ ps.setString(11, e.getSourceApi());
+ ps.setString(12, e.getOriginSessionId());
+ ps.setString(13, e.getReceiptRefBaseKey());
+ if (e.getReceiptRefType() == null) ps.setObject(14, null);
+ else ps.setInt(14, e.getReceiptRefType());
+ return ps.executeUpdate() > 0;
+ }
+ }
+ }
+
+ public SignedMessageV2Entry getByMessageKey(String messageKey) throws Exception {
+ try (Connection c = db.getConnection()) {
+ String sql = """
+ SELECT
+ message_key, base_key, target_login, from_login, to_login,
+ time_ms, nonce, message_type, raw_block, created_at_ms,
+ source_api, origin_session_id, receipt_ref_base_key, receipt_ref_type
+ FROM signed_messages_v2
+ WHERE message_key = ?
+ """;
+ try (PreparedStatement ps = c.prepareStatement(sql)) {
+ ps.setString(1, messageKey);
+ try (ResultSet rs = ps.executeQuery()) {
+ if (!rs.next()) return null;
+ return mapRow(rs);
+ }
+ }
+ }
+ }
+
+ public void ensureDeliveryRow(String messageKey, String sessionId, long nowMs) throws Exception {
+ try (Connection c = db.getConnection()) {
+ String sql = """
+ INSERT OR IGNORE INTO signed_message_session_delivery (
+ message_key, session_id, delivered, delivered_at_ms, created_at_ms
+ ) VALUES (?, ?, 0, NULL, ?)
+ """;
+ try (PreparedStatement ps = c.prepareStatement(sql)) {
+ ps.setString(1, messageKey);
+ ps.setString(2, sessionId);
+ ps.setLong(3, nowMs);
+ ps.executeUpdate();
+ }
+ }
+ }
+
+ public void markDelivered(String messageKey, String sessionId, long deliveredAtMs) throws Exception {
+ try (Connection c = db.getConnection()) {
+ String insertSql = """
+ INSERT OR IGNORE INTO signed_message_session_delivery (
+ message_key, session_id, delivered, delivered_at_ms, created_at_ms
+ ) VALUES (?, ?, 0, NULL, ?)
+ """;
+ try (PreparedStatement ps = c.prepareStatement(insertSql)) {
+ ps.setString(1, messageKey);
+ ps.setString(2, sessionId);
+ ps.setLong(3, deliveredAtMs);
+ ps.executeUpdate();
+ }
+
+ String updateSql = """
+ UPDATE signed_message_session_delivery
+ SET delivered = 1, delivered_at_ms = ?
+ WHERE message_key = ? AND session_id = ?
+ """;
+ try (PreparedStatement ps = c.prepareStatement(updateSql)) {
+ ps.setLong(1, deliveredAtMs);
+ ps.setString(2, messageKey);
+ ps.setString(3, sessionId);
+ ps.executeUpdate();
+ }
+ }
+ }
+
+ public List