normalize ensContract name before inserting a contract

AlexNi245 · AlexNi245 · commit fe4c90445a8c · 2024-02-05T18:32:56.000+01:00
diff --git a/packages/messenger-widget/src/components/Chat/Chat.tsx b/packages/messenger-widget/src/components/Chat/Chat.tsx
@@ -57,6 +57,9 @@ export function Chat(props: HideFunctionProps) {
     }, [selectedContact]);
 
     const messages = useMemo(() => {
+        if (!selectedContact?.contactDetails.account.ensName) {
+            return [];
+        }
         return getMessages(selectedContact?.contactDetails.account.ensName!);
     }, [selectedContact, getMessages]);
 
diff --git a/packages/messenger-widget/src/components/Contacts/Contacts.tsx b/packages/messenger-widget/src/components/Contacts/Contacts.tsx
@@ -145,9 +145,15 @@ export function Contacts(props: DashboardProps) {
                                             : 'contact-details-container-active'
                                         : '',
                                 )}
-                                onClick={() =>
-                                    setSelectedContactName(data.name)
-                                }
+                                onClick={() => {
+                                    console.log(
+                                        'set selected contact ',
+                                        data.contactDetails.account.ensName,
+                                    );
+                                    setSelectedContactName(
+                                        data.contactDetails.account.ensName,
+                                    );
+                                }}
                             >
                                 <div
                                     className="col-12 d-flex flex-row align-items-center 
diff --git a/packages/messenger-widget/src/hooks/auth/useAuth.ts b/packages/messenger-widget/src/hooks/auth/useAuth.ts
@@ -1,6 +1,10 @@
 /* eslint-disable no-console */
 import { useAccount, useWalletClient } from 'wagmi';
-import { Account, ProfileKeys } from '@dm3-org/dm3-lib-profile';
+import {
+    Account,
+    ProfileKeys,
+    normalizeEnsName,
+} from '@dm3-org/dm3-lib-profile';
 import { UserDB } from '@dm3-org/dm3-lib-storage';
 import { useEffect, useMemo, useState, useContext } from 'react';
 import { useMainnetProvider } from '../mainnetprovider/useMainnetProvider';
@@ -116,6 +120,7 @@ export const useAuth = (onStorageSet: (userDb: UserDB) => void) => {
         onStorageSet(userDb);
         setAccount({
             ...account,
+            ensName: normalizeEnsName(account.ensName),
             profile: signedUserProfile.profile,
             profileSignature: signedUserProfile.signature,
         });
diff --git a/packages/messenger-widget/src/hooks/conversation/useConversation.tsx b/packages/messenger-widget/src/hooks/conversation/useConversation.tsx
@@ -6,6 +6,8 @@ import { StorageContext } from '../../context/StorageContext';
 import { ContactPreview, getDefaultContract } from '../../interfaces/utils';
 import { useMainnetProvider } from '../mainnetprovider/useMainnetProvider';
 import { hydrateContract } from './hydrateContact';
+import { fetchPendingConversations } from '../../adapters/messages';
+import { normalizeEnsName } from '@dm3-org/dm3-lib-profile';
 
 export const useConversation = () => {
     const mainnetProvider = useMainnetProvider();
@@ -25,7 +27,7 @@ export const useConversation = () => {
 
     const conversationCount = useMemo(() => contacts.length, [contacts]);
 
-    const { account } = useContext(AuthContext);
+    const { account, deliveryServiceToken } = useContext(AuthContext);
 
     const selectedContact = useMemo(() => {
         return contacts.find(
@@ -40,10 +42,13 @@ export const useConversation = () => {
         setSelectedContactName(undefined);
         setContacts([]);
         const init = async (page: number = 0) => {
+            if (!account || !storageInitialized) {
+                return;
+            }
             const currentConversationsPage = await getConversations(page);
 
             //Hydrate the contacts by fetching their profile and DS profile
-            const newContacts = await Promise.all(
+            const storedContacts = await Promise.all(
                 currentConversationsPage.map((conversation) => {
                     const isHidden = conversation.isHidden;
                     //Hydrating is the most expensive operation. Hence we only hydrate if the contact is not hidden
@@ -58,7 +63,7 @@ export const useConversation = () => {
                 }),
             );
             //It might be the case that contacts are added via websocket. In this case we do not want to add them again
-            const contactsWithoutDuplicates = newContacts.filter(
+            const contactsWithoutDuplicates = storedContacts.filter(
                 (newContact) =>
                     !contacts.some(
                         (existingContact) =>
@@ -68,16 +73,31 @@ export const useConversation = () => {
             );
 
             setContacts((prev) => [...prev, ...contactsWithoutDuplicates]);
+            //as long as there is no pagination we fetch the next page until we get an empty page
             if (currentConversationsPage.length > 0) {
                 await init(page + 1);
             }
-
+            await handlePendingConversations();
             setConversationsInitialized(true);
         };
         init();
     }, [storageInitialized, account]);
 
-    const addConversation = (ensName: string) => {
+    const handlePendingConversations = async () => {
+        //At first we've to check if there are pending conversations not yet added to the list
+        const pendingConversations = await fetchPendingConversations(
+            mainnetProvider,
+            account!,
+            deliveryServiceToken!,
+        );
+        //Every pending conversation is going to be added to the conversation list
+        pendingConversations.forEach((pendingConversation) => {
+            addConversation(pendingConversation);
+        });
+    };
+
+    const addConversation = (_ensName: string) => {
+        const ensName = normalizeEnsName(_ensName);
         const alreadyAddedContact = contacts.find(
             (existingContact) =>
                 existingContact.contactDetails.account.ensName === ensName,
@@ -129,7 +149,8 @@ export const useConversation = () => {
         });
     };
 
-    const toggleHideContact = (ensName: string, isHidden: boolean) => {
+    const toggleHideContact = (_ensName: string, isHidden: boolean) => {
+        const ensName = normalizeEnsName(_ensName);
         setContacts((prev) => {
             return prev.map((existingContact) => {
                 //Find the contact in the list and replace it with the hydrated one
@@ -148,7 +169,8 @@ export const useConversation = () => {
         toggleHideContactAsync(ensName, isHidden);
     };
 
-    const hideContact = (ensName: string) => {
+    const hideContact = (_ensName: string) => {
+        const ensName = normalizeEnsName(_ensName);
         toggleHideContact(ensName, true);
         setSelectedContactName(undefined);
     };
diff --git a/packages/messenger-widget/src/hooks/messages/useMessage.tsx b/packages/messenger-widget/src/hooks/messages/useMessage.tsx
@@ -14,7 +14,14 @@ import { StorageContext } from '../../context/StorageContext';
 import { Connection } from '../../interfaces/web3';
 import { getHaltDelivery } from '../../utils/common-utils';
 import { MessageActionType } from '../../utils/enum-type-utils';
-import { encryptAsymmetric } from '@dm3-org/dm3-lib-crypto';
+import { decryptAsymmetric, encryptAsymmetric } from '@dm3-org/dm3-lib-crypto';
+import {
+    getDeliveryServiceProfile,
+    normalizeEnsName,
+} from '@dm3-org/dm3-lib-profile';
+import { useMainnetProvider } from '../mainnetprovider/useMainnetProvider';
+import axios from 'axios';
+import { fetchNewMessages } from '../../adapters/messages';
 
 type MessageStorage = { [contact: string]: StorageEnvelopContainer[] };
 
@@ -27,18 +34,20 @@ export const useMessage = (connection: Connection) => {
         getMessages: getMessagesFromStorage,
         storeMessage,
     } = useContext(StorageContext);
+
+    const mainnetProvider = useMainnetProvider();
     const [messages, setMessages] = useState<MessageStorage>({});
 
     const [contactsLoading, setContactsLoading] = useState<string[]>([]);
 
     useEffect(() => {
         //Find new contacts
         const newContacts = contacts.filter(
-            (contact) => !messages[contact.name],
+            (contact) => !messages[contact.contactDetails.account.ensName],
         );
 
         newContacts.forEach((contact) => {
-            addNewContact(contact.name);
+            addNewContact(contact.contactDetails.account.ensName);
         });
     }, [contacts]);
 
@@ -47,13 +56,15 @@ export const useMessage = (connection: Connection) => {
     }, [messages]);
 
     const contactIsLoading = useCallback(
-        (contact: string) => {
+        (_contactName: string) => {
+            const contact = normalizeEnsName(_contactName);
             return contactsLoading.includes(contact);
         },
         [contactsLoading],
     );
 
-    const addNewContact = (contact: string) => {
+    const addNewContact = (_contactName: string) => {
+        const contact = normalizeEnsName(_contactName);
         //Contact already exists
         if (messages[contact]) {
             return;
@@ -67,7 +78,8 @@ export const useMessage = (connection: Connection) => {
         loadInitialMessages(contact);
     };
 
-    const addMessage = async (contact: string, message: Message) => {
+    const addMessage = async (_contactName: string, message: Message) => {
+        const contact = normalizeEnsName(_contactName);
         //Find the recipient of the message in the contact list
         const recipient = contacts.find((c) => c.name === contact);
 
@@ -103,6 +115,7 @@ export const useMessage = (connection: Connection) => {
                     ],
                 };
             });
+            console.log('storeMessage', contact, storageEnvelopContainer);
             storeMessage(contact, storageEnvelopContainer);
             return;
         }
@@ -148,31 +161,90 @@ export const useMessage = (connection: Connection) => {
     };
 
     const getMessages = useCallback(
-        (contact: string) => {
-            return messages[contact] ?? [];
+        (_contactName: string) => {
+            const contactName = normalizeEnsName(_contactName);
+            console.log('get messages for ', contactName);
+            console.log('return messages ', messages[contactName] ?? []);
+            return messages[contactName] ?? [];
         },
         [messages],
     );
 
-    const loadInitialMessages = async (contactName: string) => {
+    const fetchMessagesFromStorage = async (contactName: string) => {
         setContactsLoading((prev) => {
             return [...prev, contactName];
         });
         const MAX_MESSAGES_PER_CHUNK = 100;
         const numberOfmessages = await getNumberOfMessages(contactName);
-        const lastMessages = await getMessagesFromStorage(
+        const storedMessages = await getMessagesFromStorage(
             contactName,
             Math.floor(numberOfmessages / MAX_MESSAGES_PER_CHUNK),
         );
 
-        console.log(numberOfmessages, lastMessages);
-        console.log(contactName, lastMessages);
+        console.log(
+            `got messages from Storage for ${contactName}`,
+            storedMessages,
+        );
 
-        const messages = lastMessages.filter(
-            ({ envelop }: StorageEnvelopContainer) => {
-                return envelop.message.metadata?.type === MessageActionType.NEW;
-            },
+        return storedMessages;
+    };
+
+    const fetchMessagesFromDeliveryService = async (contactName: string) => {
+        //Fetch the pending messages from the delivery service
+        const encryptedIncommingMessages = await fetchNewMessages(
+            mainnetProvider,
+            account!,
+            deliveryServiceToken!,
+            contactName,
+        );
+
+        const incommingMessages: StorageEnvelopContainer[] = await Promise.all(
+            encryptedIncommingMessages.map(async (envelop) => {
+                const decryptedEnvelop: Envelop = {
+                    message: JSON.parse(
+                        await decryptAsymmetric(
+                            profileKeys?.encryptionKeyPair!,
+                            JSON.parse(envelop.message),
+                        ),
+                    ),
+                    postmark: JSON.parse(
+                        await decryptAsymmetric(
+                            profileKeys?.encryptionKeyPair!,
+                            JSON.parse(envelop.postmark!),
+                        ),
+                    ),
+                    metadata: envelop.metadata,
+                };
+                return {
+                    envelop: decryptedEnvelop,
+                    //Messages from the delivery service are already send by the sender
+                    messageState: MessageState.Send,
+                };
+            }),
+        );
+
+        console.log(
+            `got messages from DS for ${contactName}`,
+            incommingMessages,
         );
+
+        return incommingMessages;
+    };
+
+    const loadInitialMessages = async (_contactName: string) => {
+        const contactName = normalizeEnsName(_contactName);
+
+        const initialMessages = await Promise.all([
+            fetchMessagesFromDeliveryService(contactName),
+            fetchMessagesFromStorage(contactName),
+        ]);
+
+        const messages = initialMessages
+            .reduce((acc, val) => acc.concat(val), [])
+            .filter(({ envelop }: StorageEnvelopContainer) => {
+                return envelop.message.metadata?.type === MessageActionType.NEW;
+            });
+
         setMessages((prev) => {
             return {
                 ...prev,
