'init'

app/providers/DialogProvider/DialogProvider.tsx

@@ -0,0 +1,836 @@
+import { chacha20Decrypt, decodeWithPassword, decrypt, encodeWithPassword, generateMd5 } from '@/app/crypto/crypto';
+import { useDatabase } from '@/app/providers/DatabaseProvider/useDatabase';
+import { createContext, useEffect, useRef, useState } from 'react';
+import { Attachment, AttachmentType, PacketMessage } from '@/app/providers/ProtocolProvider/protocol/packets/packet.message';
+import { usePrivatePlain } from '../AccountProvider/usePrivatePlain';
+import { usePublicKey } from '../AccountProvider/usePublicKey';
+import { PacketRead } from '@/app/providers/ProtocolProvider/protocol/packets/packet.read';
+import { usePrivateKeyHash } from '../AccountProvider/usePrivateKeyHash';
+import { useMemory } from '../MemoryProvider/useMemory';
+import { useBlacklist } from '../BlacklistProvider/useBlacklist';
+import { useLogger } from '@/app/hooks/useLogger';
+import { useSender } from '../ProtocolProvider/useSender';
+import { usePacket } from '../ProtocolProvider/usePacket';
+import { MAX_MESSAGES_LOAD, MESSAGE_MAX_LOADED, MESSAGE_MAX_TIME_TO_DELEVERED_S, TIME_TO_INACTIVE_FOR_MESSAGES_UNREAD } from '@/app/constants';
+import { PacketDelivery } from '@/app/providers/ProtocolProvider/protocol/packets/packet.delivery';
+import { useIdle } from '@mantine/hooks';
+import { useWindowFocus } from '@/app/hooks/useWindowFocus';
+import { useDialogsCache } from './useDialogsCache';
+import { useConsoleLogger } from '@/app/hooks/useConsoleLogger';
+import { useViewPanelsState, ViewPanelsState } from '@/app/hooks/useViewPanelsState';
+import { generateRandomKeyFormSeed } from '@/app/utils/utils';
+import { MessageReply } from './useReplyMessages';
+import { useTransport } from '../TransportProvider/useTransport';
+import { useFileStorage } from '@/app/hooks/useFileStorage';
+import { useSystemAccounts } from '../SystemAccountsProvider/useSystemAccounts';
+import { useDialogsList } from '../DialogListProvider/useDialogsList';
+import { useGroups } from './useGroups';
+import { useMentions } from '../DialogStateProvider.tsx/useMentions';
+
+export interface DialogContextValue {
+    loading: boolean;
+    messages: Message[];
+    setMessages: (messages: React.SetStateAction<Message[]>) => void;
+    dialog: string;
+    clearDialogCache: () => void;
+    prepareAttachmentsToSend: (password: string, attachments: Attachment[]) => Promise<Attachment[]>;
+    loadMessagesToTop: () => Promise<void>;
+    loadMessagesToMessageId: (messageId: string) => Promise<void>;
+}
+
+export const DialogContext = createContext<DialogContextValue | null>(null);
+
+export enum DeliveredMessageState {
+    WAITING,
+    DELIVERED,
+    ERROR
+}
+
+export interface AttachmentMeta {
+    id: string;
+    type: AttachmentType;
+    preview: string;
+}
+
+export interface Message {
+    from_public_key: string;
+    to_public_key: string;
+    content: string;
+    timestamp: number;
+    readed: number;
+    chacha_key: string;
+    from_me: number;
+    plain_message: string;
+    delivered: DeliveredMessageState;
+    message_id: string;
+    attachments: Attachment[];
+}
+
+interface DialogProviderProps {
+    children: React.ReactNode;
+    dialog: string;
+}
+
+export function DialogProvider(props: DialogProviderProps) {
+    const [messages, setMessages] = useState<Message[]>([]);
+    const {allQuery, runQuery} = useDatabase();
+    const privatePlain = usePrivatePlain();
+    const publicKey = usePublicKey();
+    const privateKey = usePrivateKeyHash();
+    const send = useSender();
+    const [__, setCurrentDialogPublicKeyView] = useMemory("current-dialog-public-key-view", "", true);
+    const log = useLogger('DialogProvider');
+    const [blocked] = useBlacklist(props.dialog)
+    const lastMessageTimeRef = useRef(0);
+    const idle = useIdle(TIME_TO_INACTIVE_FOR_MESSAGES_UNREAD * 1000);
+    const focus = useWindowFocus();
+    const [loading, setLoading] = useState(false);
+    const {getDialogCache, addOrUpdateDialogCache, dialogsCache, setDialogsCache} = useDialogsCache();
+    const {info, warn, error} = useConsoleLogger('DialogProvider');
+    const [viewState] = useViewPanelsState();
+    const {uploadFile} = useTransport();
+    const {readFile} = useFileStorage();
+    const intervalsRef = useRef<NodeJS.Timeout>(null);
+    const systemAccounts = useSystemAccounts();
+    const {updateDialog} = useDialogsList();
+    const {hasGroup, getGroupKey} = useGroups();
+    const {popMention, isMentioned} = useMentions();
+
+
+    useEffect(() => {
+        setCurrentDialogPublicKeyView(props.dialog);
+        return () => {
+            setCurrentDialogPublicKeyView("");
+        }
+    }, [props.dialog]);
+
+    useEffect(() => {
+        if(props.dialog == "demo"){
+            return;
+        }
+        if(idle){
+           return; 
+        }
+        (async () => {
+            if(hasGroup(props.dialog)){
+                await runQuery(`UPDATE messages SET read = 1 WHERE to_public_key = ? AND account = ? AND read != 1 AND from_public_key != ?`, [props.dialog, publicKey, publicKey]);
+            }else{
+                await runQuery(`UPDATE messages SET read = 1 WHERE ((from_public_key = ? AND to_public_key = ?) OR (from_public_key = ? AND to_public_key = ?)) AND account = ? AND read != 1 AND from_me = 0`, [props.dialog, publicKey, publicKey, props.dialog, publicKey]);
+            }
+            updateDialog(props.dialog);
+        })();
+    }, [idle, props.dialog]);
+
+    useEffect(() => {
+        if(props.dialog == "demo"){
+            return;
+        }
+        setMessages([]);
+        if(props.dialog == "" 
+                || privatePlain == "") {
+            return;
+        }
+        (async () => {
+            let dialogCacheEntry = getDialogCache(props.dialog);
+            if(dialogCacheEntry.length > 0){
+                const messagesToLoadFromCache = dialogCacheEntry.slice(-MESSAGE_MAX_LOADED);
+                setMessages(messagesToLoadFromCache);
+                info("Loading messages for " + props.dialog + " from cache");
+                setLoading(false);
+                if(hasGroup(props.dialog)){
+                    await runQuery(`UPDATE messages SET read = 1 WHERE to_public_key = ? AND account = ? AND read != 1 AND from_public_key != ?`, [props.dialog, publicKey, publicKey]);
+                }else{
+                    await runQuery(`UPDATE messages SET read = 1 WHERE ((from_public_key = ? AND to_public_key = ?) OR (from_public_key = ? AND to_public_key = ?)) AND account = ? AND read != 1 AND from_me = 0`, [props.dialog, publicKey, publicKey, props.dialog, publicKey]);
+                }
+                if(isMentioned(props.dialog)){
+                    /**
+                     * Удаляем упоминания потому что мы только что загрузили
+                     * диалог из кэша, может быть в нем есть упоминания
+                     */
+                    for(let i = 0; i < messagesToLoadFromCache.length; i++){
+                        const message = messagesToLoadFromCache[i];
+                        popMention({
+                            dialog_id: props.dialog,
+                            message_id: message.message_id
+                        });
+                    }
+                }
+                updateDialog(props.dialog);
+                return;
+            }
+            info("Loading messages for " + props.dialog + " from database");
+            setLoading(true);
+            let result: any[] = [];
+            if (props.dialog != publicKey) {
+                if(hasGroup(props.dialog)){
+                    result = await allQuery(`
+                    SELECT * FROM (SELECT * FROM messages WHERE (to_public_key = ?) AND account = ? ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+                `, [props.dialog, publicKey, MAX_MESSAGES_LOAD]);
+                }else{
+                    result = await allQuery(`
+                    SELECT * FROM (SELECT * FROM messages WHERE (from_public_key = ? OR to_public_key = ?) AND (from_public_key = ? OR to_public_key = ?) AND account = ? ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+                `, [props.dialog, props.dialog, publicKey, publicKey, publicKey, MAX_MESSAGES_LOAD]);
+                }
+            } else {
+                result = await allQuery(`
+                    SELECT * FROM (SELECT * FROM messages WHERE from_public_key = ? AND to_public_key = ? AND account = ? ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+                `, [publicKey, publicKey, publicKey, MAX_MESSAGES_LOAD]);
+            }
+            await runQuery(`UPDATE messages SET read = 1 WHERE ((from_public_key = ? AND to_public_key = ?) OR (from_public_key = ? AND to_public_key = ?)) AND account = ? AND read != 1 AND from_me = 0`, [props.dialog, publicKey, publicKey, props.dialog, publicKey]);
+            const finalMessages : Message[] = [];
+            let readUpdated = false;
+            for(let i = 0; i < result.length; i++){
+                const message = result[i];
+                if(message.read != 1 && !readUpdated){
+                    readUpdated = true;
+                } 
+                let decryptKey = '';
+                if(message.from_me){
+                    /**
+                     * Если сообщение от меня, то ключ расшифровки для вложений
+                     * не нужен, передаем пустую строку, так как под капотом
+                     * в MessageAttachment.tsx при расшифровке вложений используется
+                     * локальный ключ, а не тот что в сообщении, так как файл и так находится
+                     * у нас локально
+                     */
+                    decryptKey = '';
+                }
+                if(hasGroup(props.dialog)){
+                    /**
+                     * Если это групповое сообщение, то получаем ключ группы
+                     */
+                    decryptKey = await getGroupKey(props.dialog);
+                }
+                if(!message.from_me && !hasGroup(props.dialog)){
+                    /**
+                     * Если сообщение не от меня и не групповое,
+                     * расшифровываем ключ чачи своим приватным ключом
+                     */
+                    console.info("Decrypting chacha key for message");
+                    decryptKey = Buffer.from(await decrypt(message.chacha_key, privatePlain), "binary").toString('utf-8');
+                }   
+                finalMessages.push({
+                    from_public_key: message.from_public_key,
+                    to_public_key: message.to_public_key,
+                    content: "__ENCRYPTED__",
+                    timestamp: message.timestamp,
+                    readed: message.read || message.from_public_key == message.to_public_key,
+                    chacha_key: decryptKey,
+                    from_me: message.from_me,
+                    plain_message: await loadMessage(message.plain_message),
+                    delivered: message.delivered,
+                    message_id: message.message_id,
+                    attachments: await loadAttachments(message.attachments)
+                });
+                if(isMentioned(props.dialog)){
+                    /**
+                     * Если мы были упомянуты в этом диалоге, то убираем упоминание,
+                     * так как мы только что загрузили это сообщение
+                     */
+                    popMention({
+                        dialog_id: props.dialog,
+                        message_id: message.message_id
+                    });
+                }
+                
+            }
+            if(readUpdated){
+                updateDialog(props.dialog);
+            }
+            setMessages(finalMessages);
+            setLoading(false);
+        })();
+    }, [props.dialog]);
+
+    useEffect(() => {
+        if(props.dialog == "demo"){
+            return;
+        }
+        if(!messages || messages.length == 0){
+            return;
+        }
+        addOrUpdateDialogCache(props.dialog, messages);
+    }, [props.dialog, messages])
+
+    useEffect(() => {
+        if(props.dialog == publicKey || messages.length == 0
+            || blocked 
+            || idle
+            || lastMessageTimeRef.current == messages[messages.length - 1].timestamp
+            || !focus){
+            return;
+        }
+        if(viewState == ViewPanelsState.DIALOGS_PANEL_ONLY){
+            /**
+             * Если мы сейчас видим только диалоги
+             * то сообщение мы не читаем
+             */
+            return;
+        }
+        if(systemAccounts.find(acc => acc.publicKey == props.dialog)){
+            /**
+             * Системные аккаунты не отмечаем как прочитанные
+             */
+            return;
+        }
+        const readPacket = new PacketRead();
+        readPacket.setFromPublicKey(publicKey);
+        readPacket.setToPublicKey(props.dialog);
+        readPacket.setPrivateKey(privateKey);
+        send(readPacket);
+        log("Send read packet to " + props.dialog);
+        info("Send read packet");
+        lastMessageTimeRef.current = messages[messages.length - 1].timestamp;
+    }, [props.dialog, viewState, focus, messages, blocked, idle]);
+
+    usePacket(0x07, async (packet : PacketRead) => {
+        info("Read packet received in dialog provider");
+        const fromPublicKey = packet.getFromPublicKey();
+        if(hasGroup(props.dialog)){
+            /**
+             * Для групп обработка чтения есть ниже
+             */
+            return;
+        }
+        if(fromPublicKey != props.dialog && !idle){
+            return;
+        }
+        setMessages((prev) => prev.map((msg) => {
+            if(msg.from_public_key == publicKey && !msg.readed){
+                return {
+                    ...msg,
+                    readed: 1
+                }
+            }
+            return msg;
+        }));
+        //updateDialog(props.dialog);
+    }, [idle, props.dialog]);
+
+    usePacket(0x07, async (packet : PacketRead) => {
+        info("Read packet received in dialog provider");
+        //const fromPublicKey = packet.getFromPublicKey();
+        const toPublicKey = packet.getToPublicKey();
+        if(!hasGroup(props.dialog)){
+            /**
+             * Для личных сообщений обработка чтения выше
+             */
+            return;
+        }
+        if(toPublicKey != props.dialog && !idle){
+            return;
+        }
+        setMessages((prev) => prev.map((msg) => {
+            if(msg.from_public_key == publicKey && !msg.readed){
+                return {
+                    ...msg,
+                    readed: 1
+                }
+            }
+            return msg;
+        }));
+        //updateDialog(props.dialog);
+    }, [idle, props.dialog]);
+
+    usePacket(0x08, async (packet : PacketDelivery) => {
+        info("Delivery packet received in dialog provider");
+        const fromPublicKey = packet.getToPublicKey();
+        const messageId = packet.getMessageId();
+        if(fromPublicKey != props.dialog){
+            return;
+        }
+        setMessages((prev) => prev.map((msg) => {
+            if(msg.message_id == messageId && msg.delivered != DeliveredMessageState.DELIVERED){
+                return {
+                    ...msg,
+                    delivered: DeliveredMessageState.DELIVERED,
+                    timestamp: Date.now()
+                }
+            }
+            return msg;
+        }));
+    }, [props.dialog]);    
+
+    /**
+     * Обработчик для личных сообщений
+     */
+    usePacket(0x06, async (packet: PacketMessage) => {
+        const fromPublicKey = packet.getFromPublicKey();
+        const toPublicKey = packet.getToPublicKey();
+
+        if(hasGroup(props.dialog)){
+            /**
+             * Если это групповое сообщение, то для него есть
+             * другой обработчик ниже
+             */
+            return;
+        }
+        if(fromPublicKey != props.dialog || toPublicKey != publicKey){
+            console.info("From " + fromPublicKey + " to " + props.dialog + " ignore");
+            return;
+        }        
+        if(blocked){
+            warn("Message from blocked user, ignore " + fromPublicKey);
+            log("Message from blocked user, ignore " + fromPublicKey);
+            return;
+        }
+
+
+        const content = packet.getContent();
+        const chachaKey = packet.getChachaKey();
+        const timestamp = packet.getTimestamp();
+
+        /**
+         * Генерация рандомного ID сообщения по SEED нужна для того, 
+         * чтобы сообщение записанное здесь в стек сообщений совпадало
+         * с тем что записывается в БД в файле useDialogFiber.ts
+         */
+        const messageId = generateRandomKeyFormSeed(16, fromPublicKey + toPublicKey + timestamp.toString());
+        const chachaDecryptedKey = Buffer.from(
+            await decrypt(chachaKey, privatePlain), 
+            "binary");
+        const key = chachaDecryptedKey.slice(0, 32);
+        const nonce = chachaDecryptedKey.slice(32);
+        const decryptedContent = await chacha20Decrypt(content, nonce.toString('hex'), key.toString('hex'));
+        
+
+        let attachments: Attachment[] = [];
+        for(let i = 0; i < packet.getAttachments().length; i++) {
+            const attachment = packet.getAttachments()[i];
+            attachments.push({
+                id: attachment.id,
+                preview: attachment.preview,
+                type: attachment.type,
+                blob: attachment.type == AttachmentType.MESSAGES ? await decodeWithPassword(chachaDecryptedKey.toString('utf-8'), attachment.blob) : ""
+            });
+        }
+
+        const newMessage : Message = {
+            from_public_key: fromPublicKey,
+            to_public_key: toPublicKey,
+            content: content,
+            timestamp: timestamp,
+            readed: idle ? 0 : 1,
+            chacha_key: chachaDecryptedKey.toString('utf-8'),
+            from_me: fromPublicKey == publicKey ? 1 : 0,
+            plain_message: (decryptedContent as string),
+            delivered: DeliveredMessageState.DELIVERED,
+            message_id: messageId,
+            attachments: attachments
+        };
+
+        setMessages((prev) => ([...prev, newMessage]));
+    }, [blocked, messages, idle, props.dialog]);
+
+    /**
+     * Обработчик для групповых сообщений
+     */
+    usePacket(0x06, async (packet: PacketMessage) => {
+        const fromPublicKey = packet.getFromPublicKey();
+        const toPublicKey = packet.getToPublicKey();
+
+        if(toPublicKey != props.dialog){
+            /**
+             * Исправление кросс диалогового сообщения
+             */
+            return;
+        }
+
+        if(!hasGroup(props.dialog)){
+            /**
+             * Если это не групповое сообщение, то для него есть
+             * другой обработчик выше
+             */
+            return;
+        }
+        const content = packet.getContent();
+        const timestamp = packet.getTimestamp();
+        /**
+         * Генерация рандомного ID сообщения по SEED нужна для того, 
+         * чтобы сообщение записанное здесь в стек сообщений совпадало
+         * с тем что записывается в БД в файле useDialogFiber.ts
+         */
+        const messageId = generateRandomKeyFormSeed(16, fromPublicKey + toPublicKey + timestamp.toString());
+
+        const groupKey = await getGroupKey(toPublicKey);
+        if(!groupKey){
+            log("Group key not found for group " + toPublicKey);
+            error("Message dropped because group key not found for group " + toPublicKey);
+            return;
+        }
+        info("New group message packet received from " + fromPublicKey);
+
+        let decryptedContent = '';
+
+        try{
+            decryptedContent = await decodeWithPassword(groupKey, content);
+        }catch(e) {
+            decryptedContent = '';
+        }
+
+        let attachments: Attachment[] = [];
+        for(let i = 0; i < packet.getAttachments().length; i++) {
+            const attachment = packet.getAttachments()[i];
+            attachments.push({
+                id: attachment.id,
+                preview: attachment.preview,
+                type: attachment.type,
+                blob: attachment.type == AttachmentType.MESSAGES ? await decodeWithPassword(groupKey, attachment.blob) : ""
+            });
+        }
+
+        const newMessage : Message = {
+            from_public_key: fromPublicKey,
+            to_public_key: toPublicKey,
+            content: content,
+            timestamp: timestamp,
+            readed: idle ? 0 : 1,
+            chacha_key: groupKey,
+            from_me: fromPublicKey == publicKey ? 1 : 0,
+            plain_message: decryptedContent,
+            delivered: DeliveredMessageState.DELIVERED,
+            message_id: messageId,
+            attachments: attachments
+        };
+
+        setMessages((prev) => ([...prev, newMessage]));
+    }, [messages, idle, props.dialog]);    
+
+    /**
+     * Расшифровывает сообщение
+     * @param message Зашифрованное сообщение
+     * @returns Расшифрованное сообщение
+     */
+    const loadMessage = async (message : string) => {
+        try{
+            return await decodeWithPassword(privatePlain, message);
+        }catch(e){
+            return "";
+        }
+    }
+
+    /**
+     * Загружает часть диалога где есть определенный message_id
+     */
+    const loadMessagesToMessageId = async (messageId: string) => {
+        warn("Load messages to message ID " + messageId + " for " + props.dialog);
+        if(props.dialog == "DELETED" 
+                || privatePlain == "") {
+            return;
+        }
+        let result : any[] = [];
+        if(props.dialog != publicKey){
+            if(hasGroup(props.dialog)){
+                result = await allQuery(`
+                    SELECT * FROM (SELECT * FROM messages WHERE (to_public_key = ?) AND account = ? AND timestamp <= (SELECT timestamp FROM messages WHERE message_id = ? AND account = ?) ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+                `, [props.dialog, publicKey, messageId, publicKey, MAX_MESSAGES_LOAD]);
+            }else{
+                result = await allQuery(`
+                    SELECT * FROM (SELECT * FROM messages WHERE (from_public_key = ? OR to_public_key = ?) AND (from_public_key = ? OR to_public_key = ?) AND account = ? AND timestamp <= (SELECT timestamp FROM messages WHERE message_id = ? AND account = ?) ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+                `, [props.dialog, props.dialog, publicKey, publicKey, publicKey, messageId, publicKey, MAX_MESSAGES_LOAD]);
+            }
+        }else{
+            result = await allQuery(`
+                SELECT * FROM (SELECT * FROM messages WHERE from_public_key = ? AND to_public_key = ? AND account = ? AND timestamp <= (SELECT timestamp FROM messages WHERE message_id = ? AND account = ?) ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+            `, [publicKey, publicKey, publicKey, messageId, publicKey, MAX_MESSAGES_LOAD]);
+        }
+        const finalMessages : Message[] = [];
+        for(let i = 0; i < result.length; i++){
+            const message = result[i];
+            let decryptKey = '';
+            if(message.from_me){
+                /**
+                 * Если сообщение от меня, то ключ расшифровки для вложений
+                 * не нужен, передаем пустую строку, так как под капотом
+                 * в MessageAttachment.tsx при расшифровке вложений используется
+                 * локальный ключ, а не тот что в сообщении, так как файл и так находится
+                 * у нас локально
+                 */
+                decryptKey = '';
+            }
+            if(hasGroup(props.dialog)){
+                /**
+                 * Если это групповое сообщение, то получаем ключ группы
+                 */
+                decryptKey = await getGroupKey(props.dialog);
+            }
+            if(!message.from_me && !hasGroup(props.dialog)){
+                /**
+                 * Если сообщение не от меня и не групповое,
+                 * расшифровываем ключ чачи своим приватным ключом
+                 */
+                decryptKey = Buffer.from(await decrypt(message.chacha_key, privatePlain), "binary").toString('utf-8');
+            }               
+            finalMessages.push({    
+                from_public_key: message.from_public_key,
+                to_public_key: message.to_public_key,
+                content: "__ENCRYPTED__",
+                timestamp: message.timestamp,
+                readed: message.read || message.from_public_key == message.to_public_key || !message.from_me,
+                chacha_key: decryptKey,
+                from_me: message.from_me,
+                plain_message: await loadMessage(message.plain_message),
+                delivered: message.delivered,
+                message_id: message.message_id,
+                attachments: await loadAttachments(message.attachments)
+            });
+
+            if(isMentioned(props.dialog)){
+                /**
+                 * Если мы были упомянуты в этом диалоге, то убираем упоминание,
+                 * так как мы только что загрузили это сообщение
+                 */
+                popMention({
+                    dialog_id: props.dialog,
+                    message_id: message.message_id
+                });
+            }
+        }
+        if(finalMessages.length == 0) {
+            return;
+        }
+        setMessages([...finalMessages]);
+    }
+
+    /**
+     * Загружает сообщения в верх диалога, когда пользователь 
+     * скроллит вверх и доскроллил до конца
+     * @returns 
+     */
+    const loadMessagesToTop = async () => {
+        warn("Load messages to top for " + props.dialog);
+        if(props.dialog == "DELETED" 
+                || privatePlain == "") {
+            return;
+        }
+        let result : any[] = [];
+        if(props.dialog != publicKey){
+            if(hasGroup(props.dialog)){
+                result = await allQuery(`
+                    SELECT * FROM (SELECT * FROM messages WHERE (to_public_key = ?) AND account = ? AND timestamp < ? ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+                `, [props.dialog, publicKey, messages.length > 0 ? messages[0].timestamp : Math.floor(Date.now() / 1000), MAX_MESSAGES_LOAD]);
+            }else{
+                result = await allQuery(`
+                    SELECT * FROM (SELECT * FROM messages WHERE (from_public_key = ? OR to_public_key = ?) AND (from_public_key = ? OR to_public_key = ?) AND account = ? AND timestamp < ? ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+                `, [props.dialog, props.dialog, publicKey, publicKey, publicKey, messages.length > 0 ? messages[0].timestamp : Math.floor(Date.now() / 1000), MAX_MESSAGES_LOAD]);
+            }
+        }else{
+            result = await allQuery(`
+                SELECT * FROM (SELECT * FROM messages WHERE from_public_key = ? AND to_public_key = ? AND account = ? AND timestamp < ? ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC
+            `, [publicKey, publicKey, publicKey, messages.length > 0 ? messages[0].timestamp : Math.floor(Date.now() / 1000), MAX_MESSAGES_LOAD]);
+        }
+        const finalMessages : Message[] = [];
+        for(let i = 0; i < result.length; i++){
+            const message = result[i];
+            let decryptKey = '';
+            if(message.from_me){
+                /**
+                 * Если сообщение от меня, то ключ расшифровки для вложений
+                 * не нужен, передаем пустую строку, так как под капотом
+                 * в MessageAttachment.tsx при расшифровке вложений используется
+                 * локальный ключ, а не тот что в сообщении, так как файл и так находится
+                 * у нас локально
+                 */
+                decryptKey = '';
+            }
+            if(hasGroup(props.dialog)){
+                /**
+                 * Если это групповое сообщение, то получаем ключ группы
+                 */
+                decryptKey = await getGroupKey(props.dialog);
+            }
+            if(!message.from_me && !hasGroup(props.dialog)){
+                /**
+                 * Если сообщение не от меня и не групповое,
+                 * расшифровываем ключ чачи своим приватным ключом
+                 */
+                decryptKey = Buffer.from(await decrypt(message.chacha_key, privatePlain), "binary").toString('utf-8');
+            }               
+            finalMessages.push({    
+                from_public_key: message.from_public_key,
+                to_public_key: message.to_public_key,
+                content: "__ENCRYPTED__",
+                timestamp: message.timestamp,
+                readed: message.read || message.from_public_key == message.to_public_key || !message.from_me,
+                chacha_key: decryptKey,
+                from_me: message.from_me,
+                plain_message: await loadMessage(message.plain_message),
+                delivered: message.delivered,
+                message_id: message.message_id,
+                attachments: await loadAttachments(message.attachments)
+            });
+
+            if(isMentioned(props.dialog)){
+                /**
+                 * Если мы были упомянуты в этом диалоге, то убираем упоминание,
+                 * так как мы только что загрузили это сообщение
+                 */
+                popMention({
+                    dialog_id: props.dialog,
+                    message_id: message.message_id
+                });
+            }
+        }
+        if(finalMessages.length == 0) {
+            return;
+        }
+        setMessages([...finalMessages, ...messages]);
+    }
+
+    /**
+     * Загружает вложения из JSON строки. 
+     * Если вложение не было загружено (то есть его нет на диске),
+     * то в blob кладется пустая строка, далее в useAttachment 
+     * это отработается (загрузится превью вложение и появится возможность скачать и тд)
+     * @param jsonAttachments JSON вложений AttachmentMeta формат
+     * @returns Вложения
+     */
+    const loadAttachments = async (jsonAttachments : string) : Promise<Attachment[]> => {
+        if(jsonAttachments == "[]") {
+            return [];
+        }
+        try {
+            const attachmentsMeta : AttachmentMeta[] = JSON.parse(jsonAttachments);
+            const attachments : Attachment[] = [];
+            for(const meta of attachmentsMeta) {
+                if(meta.type == AttachmentType.FILE){
+                    /**
+                     * Все кроме файлов декодируем заранее
+                     */
+                    attachments.push({
+                        ...meta,
+                        blob: ""
+                    });
+                    continue;
+                }
+                const fileData = await readFile(`m/${await generateMd5(meta.id + publicKey)}`);
+                if(!fileData) {
+                    attachments.push({
+                        ...meta,
+                        blob: ""
+                    });                    
+                    continue;
+                } 
+                const decrypted = await decodeWithPassword(privatePlain, Buffer.from(fileData, 'binary').toString());
+                attachments.push({
+                    id: meta.id,
+                    blob: decrypted,
+                    type: meta.type,
+                    preview: meta.preview
+                });
+            }
+            return attachments;
+        }catch(e) {
+            error("Failed to parse attachments");
+        }
+        return [];
+    }
+
+    /**
+     * Обновляет временную метку в сообщении, пока вложения отправляются,
+     * потому что если этого не делать, то сообщение может быть помечено как
+     * не доставленное из-за таймаута доставки
+     * @param attachments Вложения
+     */
+    const doTimestampUpdateImMessageWhileAttachmentsSend = (attachments : Attachment[]) => {
+        if(intervalsRef.current){
+            clearInterval(intervalsRef.current);
+        }
+        intervalsRef.current = setInterval(() => {
+            //update timestamp in message to keep message marked as error
+            updateDialog(props.dialog);
+            setMessages((prev) => {
+                return prev.map((value) => {
+                    if(value.attachments.length <= 0){
+                        return value;
+                    }
+                    if(value.attachments[0].id != attachments[0].id){
+                        return value;
+                    }
+                    runQuery("UPDATE messages SET timestamp = ? WHERE message_id = ?", [Date.now(), value.message_id]);
+                    return {
+                        ...value,
+                        timestamp: Date.now()
+                    };
+                })
+            });
+        }, (MESSAGE_MAX_TIME_TO_DELEVERED_S / 2) * 1000);
+    }
+
+    /**
+     * Удаляет старый тег если вложения были подготовлены заново
+     * например при пересылке сообщений
+     */
+    const removeOldTagIfAttachemtnsRePreapred = (preview : string) => {
+        if(preview.indexOf("::") == -1){
+            return preview;
+        }
+        let parts = preview.split("::");
+        return parts.slice(1).join("::");
+    }
+
+    /**
+     * Подготавливает вложения для отправки. Подготовка
+     * состоит в загрузке файлов на транспортный сервер, мы не делаем
+     * это через WebSocket из-за ограничений по размеру сообщений,
+     * а так же из-за надежности доставки файлов через HTTP
+     * @param attachments Attachments to prepare for sending
+     */
+    const prepareAttachmentsToSend = async (password: string, attachments : Attachment[], rePrepared : boolean = false) : Promise<Attachment[]> => {
+        if(attachments.length <= 0){
+            return [];
+        }
+        let prepared : Attachment[] = [];
+        try{
+            for(let i = 0; i < attachments.length; i++){
+                const attachment : Attachment = attachments[i];
+                if(attachment.type == AttachmentType.MESSAGES){
+                    let reply : MessageReply[] = JSON.parse(attachment.blob)
+                    for(let j = 0; j < reply.length; j++){
+                        reply[j].attachments = await prepareAttachmentsToSend(password, reply[j].attachments, true);
+                    }
+                    prepared.push({
+                        ...attachment,
+                        blob: await encodeWithPassword(password, JSON.stringify(reply))
+                    });
+                    continue;
+                }
+                doTimestampUpdateImMessageWhileAttachmentsSend(attachments);
+                const content = await encodeWithPassword(password, attachment.blob);
+                const upid = attachment.id;
+                info(`Uploading attachment with upid: ${upid}`);
+                info(`Attachment content length: ${content.length}`);
+                let tag = await uploadFile(upid, content);
+                info(`Uploaded attachment with upid: ${upid}, received tag: ${tag}`);
+                if(intervalsRef.current != null){
+                    clearInterval(intervalsRef.current);
+                }
+                prepared.push({
+                    ...attachment,
+                    preview: tag + "::" + (rePrepared ? removeOldTagIfAttachemtnsRePreapred(attachment.preview) : attachment.preview),
+                    blob: ""
+                });
+            }
+            return prepared;
+        }catch(e){
+            return prepared;
+        }
+    }
+
+    return (
+        <DialogContext.Provider value={{
+            loading,
+            messages, 
+            setMessages,
+            clearDialogCache: () => {
+                setDialogsCache(dialogsCache.filter((cache) => cache.publicKey != props.dialog));
+            },
+            dialog: props.dialog,
+            prepareAttachmentsToSend,
+            loadMessagesToTop,
+            loadMessagesToMessageId
+        }}>
+            {props.children}
+        </DialogContext.Provider> 
+    )
+}