cases

src/background-cases.ts

@@ -6,8 +6,10 @@ import {
   banFromGroup,
   cancelBan,
   cancelInvitationToGroup,
+  checkThreads,
   clearAllNotifications,
   createGroup,
+  decryptSingleFunc,
   decryptWallet,
   findUsableApi,
   getApiKeyFromStorage,
@@ -23,6 +25,7 @@ import {
   getTimestampGroupAnnouncement,
   getUserInfo,
   getUserSettings,
+  handleActiveGroupDataFromSocket,
   inviteToGroup,
   joinGroup,
   kickFromGroup,
@@ -37,10 +40,12 @@ import {
   sendCoin,
   setChatHeads,
   setGroupData,
+  updateThreadActivity,
   walletVersion,
 } from "./background";
-import { encryptAndPublishSymmetricKeyGroupChat } from "./backgroundFunctions/encryption";
+import { decryptGroupEncryption, encryptAndPublishSymmetricKeyGroupChat, publishGroupEncryptedResource, publishOnQDN } from "./backgroundFunctions/encryption";
 import { PUBLIC_NOTIFICATION_CODE_FIRST_SECRET_KEY } from "./constants/codes";
+import { encryptSingle } from "./qdn/encryption/group-encryption";
 
 export function versionCase(request, event) {
   event.source.postMessage(
@@ -1182,3 +1187,232 @@ export async function encryptAndPublishSymmetricKeyGroupChatCase(
     );
   }
 }
+
+export async function publishGroupEncryptedResourceCase(request, event) {
+    try {
+      const {encryptedData, identifier} = request.payload;
+      const response = await publishGroupEncryptedResource({encryptedData, identifier});
+  
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "publishGroupEncryptedResource",
+          payload: response,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    } catch (error) {
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "publishGroupEncryptedResource",
+          error: error?.message,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    }
+  }
+
+  export async function publishOnQDNCase(request, event) {
+    try {
+      const {data, identifier, service, title,
+          description,
+          category,
+          tag1,
+          tag2,
+          tag3,
+          tag4,
+          tag5, uploadType} = request.payload;
+      const response = await publishOnQDN({data, identifier, service, title,
+          description,
+          category,
+          tag1,
+          tag2,
+          tag3,
+          tag4,
+          tag5, uploadType});
+  
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "publishOnQDN",
+          payload: response,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    } catch (error) {
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "publishOnQDN",
+          error: error?.message || 'Unable to publish',
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    }
+  }
+
+  export async function handleActiveGroupDataFromSocketCase(request, event) {
+    try {
+      const {groups, directs} = request.payload;
+      const response = await handleActiveGroupDataFromSocket({groups, directs});
+  
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "handleActiveGroupDataFromSocket",
+          payload: true,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    } catch (error) {
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "handleActiveGroupDataFromSocket",
+          error: error?.message,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    }
+  }
+
+  export async function getThreadActivityCase(request, event) {
+    try {
+      const response = await checkThreads(true)
+  
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "getThreadActivity",
+          payload: response,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    } catch (error) {
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "getThreadActivity",
+          error: error?.message,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    }
+  }
+
+  export async function updateThreadActivityCase(request, event) {
+    try {
+      const { threadId, qortalName, groupId, thread} = request.payload;
+      const response = await updateThreadActivity({ threadId, qortalName, groupId, thread });
+  
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "updateThreadActivity",
+          payload: response,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    } catch (error) {
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "updateThreadActivity",
+          error: error?.message,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    }
+  }
+
+  export async function decryptGroupEncryptionCase(request, event) {
+    try {
+      const { data} = request.payload;
+      const response = await decryptGroupEncryption({ data });
+  
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "decryptGroupEncryption",
+          payload: response,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    } catch (error) {
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "decryptGroupEncryption",
+          error: error?.message,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    }
+  }
+
+  export async function encryptSingleCase(request, event) {
+    try {
+      const { data, secretKeyObject, typeNumber} = request.payload;
+      const response = await encryptSingle({ data, secretKeyObject, typeNumber });
+  
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "encryptSingle",
+          payload: response,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    } catch (error) {
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "encryptSingle",
+          error: error?.message,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    }
+  }
+
+  export async function decryptSingleCase(request, event) {
+    try {
+      const { data, secretKeyObject, skipDecodeBase64} = request.payload;
+      const response = await decryptSingleFunc({ data, secretKeyObject, skipDecodeBase64 });
+  
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "decryptSingle",
+          payload: response,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    } catch (error) {
+      event.source.postMessage(
+        {
+          requestId: request.requestId,
+          action: "decryptSingle",
+          error: error?.message,
+          type: "backgroundMessageResponse",
+        },
+        event.origin
+      );
+    }
+  }

src/background.ts

@@ -39,17 +39,22 @@ import {
   cancelInvitationToGroupCase,
   clearAllNotificationsCase,
   createGroupCase,
+  decryptGroupEncryptionCase,
+  decryptSingleCase,
   decryptWalletCase,
   encryptAndPublishSymmetricKeyGroupChatCase,
+  encryptSingleCase,
   getApiKeyCase,
   getCustomNodesFromStorageCase,
   getDataPublishesCase,
   getGroupDataSingleCase,
   getGroupNotificationTimestampCase,
   getTempPublishCase,
+  getThreadActivityCase,
   getTimestampEnterChatCase,
   getUserSettingsCase,
   getWalletInfoCase,
+  handleActiveGroupDataFromSocketCase,
   inviteToGroupCase,
   joinGroupCase,
   kickFromGroupCase,
@@ -59,6 +64,8 @@ import {
   nameCase,
   notificationCase,
   notifyAdminRegenerateSecretKeyCase,
+  publishGroupEncryptedResourceCase,
+  publishOnQDNCase,
   registerNameCase,
   removeAdminCase,
   saveTempPublishCase,
@@ -67,6 +74,7 @@ import {
   setChatHeadsCase,
   setCustomNodesCase,
   setGroupDataCase,
+  updateThreadActivityCase,
   userInfoCase,
   validApiCase,
   versionCase,
@@ -470,7 +478,12 @@ async function getThreadActivity() {
   }
 }
 
-async function updateThreadActivity({ threadId, qortalName, groupId, thread }) {
+export async function updateThreadActivity({
+  threadId,
+  qortalName,
+  groupId,
+  thread,
+}) {
   const wallet = await getSaveWallet();
   const address = wallet.address0;
   const ONE_WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000; // One week in milliseconds
@@ -707,7 +720,7 @@ const handleNotification = async (groups) => {
   }
 };
 
-const checkThreads = async (bringBack) => {
+export const checkThreads = async (bringBack) => {
   try {
     let myName = "";
     const userData = await getUserInfo();
@@ -1567,7 +1580,7 @@ const getStoredData = async (key) => {
   });
 };
 
-async function handleActiveGroupDataFromSocket({ groups, directs }) {
+export async function handleActiveGroupDataFromSocket({ groups, directs }) {
   try {
     chrome.runtime.sendMessage({
       action: "SET_GROUPS",
@@ -1799,7 +1812,7 @@ async function sendChatDirect({
   return _response;
 }
 
-async function decryptSingleFunc({
+export async function decryptSingleFunc({
   messages,
   secretKeyObject,
   skipDecodeBase64,
@@ -3039,11 +3052,35 @@ function setupMessageListener() {
       case "getGroupNotificationTimestamp":
         getGroupNotificationTimestampCase(request, event);
         break;
-        case "encryptAndPublishSymmetricKeyGroupChat":
+      case "encryptAndPublishSymmetricKeyGroupChat":
-          encryptAndPublishSymmetricKeyGroupChatCase(request, event);
+        encryptAndPublishSymmetricKeyGroupChatCase(request, event);
+        break;
+      case "publishGroupEncryptedResource":
+        publishGroupEncryptedResourceCase(request, event);
+        break;
+      case "publishOnQDN":
+        publishOnQDNCase(request, event);
+        break;
+      case "handleActiveGroupDataFromSocket":
+        handleActiveGroupDataFromSocketCase(request, event);
+        break;
+      case "getThreadActivity":
+        getThreadActivityCase(request, event);
+        break;
+      case "updateThreadActivity":
+        updateThreadActivityCase(request, event);
+      case "decryptGroupEncryption":
+        decryptGroupEncryptionCase(request, event);
+        break;
+      case "encryptSingle":
+        encryptSingleCase(request, event);
+        break;
+        case "decryptSingle":
+          decryptSingleCase(request, event);
           break;
       default:
         console.error("Unknown action:", request.action);
+        break
     }
   });
 }

src/components/Apps/AppPublish.tsx

@@ -201,31 +201,30 @@ export const AppPublish = ({ names, categories }) => {
       setIsLoading("Publishing... Please wait.");
       const fileBase64 = await fileToBase64(file);
       await new Promise((res, rej) => {
-        chrome?.runtime?.sendMessage(
+        window.sendMessage("publishOnQDN", {
-          {
+          data: fileBase64,
-            action: "publishOnQDN",
+          service: appType,
-            payload: {
+          title,
-              data: fileBase64,
+          description,
-              service: appType,
+          category,
-              title,
+          tag1,
-              description,
+          tag2,
-              category,
+          tag3,
-              tag1,
+          tag4,
-              tag2,
+          tag5,
-              tag3,
+          uploadType: "zip",
-              tag4,
+        })
-              tag5,
+          .then((response) => {
-              uploadType: 'zip'
-            },
-          },
-          (response) => {
             if (!response?.error) {
               res(response);
               return;
             }
             rej(response.error);
-          }
+          })
-        );
+          .catch((error) => {
+            rej(error.message || "An error occurred");
+          });
+        
       });
       setInfoSnack({
         type: "success",

src/components/Chat/AnnouncementDiscussion.tsx

@@ -75,23 +75,21 @@ export const AnnouncementDiscussion = ({
       if (!selectedAnnouncement) return;
     
       return new Promise((res, rej) => {
-        chrome?.runtime?.sendMessage(
+        window.sendMessage("publishGroupEncryptedResource", {
-          {
+          encryptedData,
-            action: "publishGroupEncryptedResource",
+          identifier,
-            payload: {
+        })
-              encryptedData,
+          .then((response) => {
-              identifier,
-            },
-          },
-          (response) => {
-         
             if (!response?.error) {
               res(response);
-              return
+              return;
             }
             rej(response.error);
-          }
+          })
-        );
+          .catch((error) => {
+            rej(error.message || "An error occurred");
+          });
+        
       });
     } catch (error) {}
   };

src/components/Chat/ChatGroup.tsx

@@ -125,184 +125,165 @@ export const ChatGroup = ({selectedGroup, secretKey, setSecretKey, getSecretKey,
           return
         }
         return new Promise((res, rej)=> {
-          chrome?.runtime?.sendMessage({ action: "decryptSingle", payload: {
+          window.sendMessage("decryptSingle", {
             data: encryptedMessages,
-            secretKeyObject: secretKey
+            secretKeyObject: secretKey,
-        }}, (response) => {
+          })
-            if (!response?.error) {
+            .then((response) => {
-              const filterUImessages = encryptedMessages.filter((item)=> !isExtMsg(item.data))
+              if (!response?.error) {
-              const decodedUIMessages = decodeBase64ForUIChatMessages(filterUImessages)
+                const filterUIMessages = encryptedMessages.filter((item) => !isExtMsg(item.data));
-
+                const decodedUIMessages = decodeBase64ForUIChatMessages(filterUIMessages);
-              const combineUIAndExtensionMsgs = [...decodedUIMessages, ...response]
+          
-              processWithNewMessages(combineUIAndExtensionMsgs?.map((item)=> {
+                const combineUIAndExtensionMsgs = [...decodedUIMessages, ...response];
-                return {
+                processWithNewMessages(
-                  ...item,
+                  combineUIAndExtensionMsgs.map((item) => ({
-                  ...(item?.decryptedData || {})
+                    ...item,
+                    ...(item?.decryptedData || {}),
+                  })),
+                  selectedGroup
+                );
+                res(combineUIAndExtensionMsgs);
+          
+                if (isInitiated) {
+                  const formatted = combineUIAndExtensionMsgs
+                    .filter((rawItem) => !rawItem?.chatReference)
+                    .map((item) => ({
+                      ...item,
+                      id: item.signature,
+                      text: item?.decryptedData?.message || "",
+                      repliedTo: item?.repliedTo || item?.decryptedData?.repliedTo,
+                      unread: item?.sender === myAddress ? false : !!item?.chatReference ? false : true,
+                      isNotEncrypted: !!item?.messageText,
+                    }));
+                  setMessages((prev) => [...prev, ...formatted]);
+          
+                  setChatReferences((prev) => {
+                    const organizedChatReferences = { ...prev };
+          
+                    combineUIAndExtensionMsgs
+                      .filter((rawItem) => rawItem && rawItem.chatReference && rawItem.decryptedData?.type === "reaction")
+                      .forEach((item) => {
+                        try {
+                          const content = item.decryptedData?.content;
+                          const sender = item.sender;
+                          const newTimestamp = item.timestamp;
+                          const contentState = item.decryptedData?.contentState;
+          
+                          if (!content || typeof content !== "string" || !sender || typeof sender !== "string" || !newTimestamp) {
+                            console.warn("Invalid content, sender, or timestamp in reaction data", item);
+                            return;
+                          }
+          
+                          organizedChatReferences[item.chatReference] = {
+                            ...(organizedChatReferences[item.chatReference] || {}),
+                            reactions: organizedChatReferences[item.chatReference]?.reactions || {},
+                          };
+          
+                          organizedChatReferences[item.chatReference].reactions[content] =
+                            organizedChatReferences[item.chatReference].reactions[content] || [];
+          
+                          let latestTimestampForSender = null;
+          
+                          organizedChatReferences[item.chatReference].reactions[content] = 
+                            organizedChatReferences[item.chatReference].reactions[content].filter((reaction) => {
+                              if (reaction.sender === sender) {
+                                latestTimestampForSender = Math.max(latestTimestampForSender || 0, reaction.timestamp);
+                              }
+                              return reaction.sender !== sender;
+                            });
+          
+                          if (latestTimestampForSender && newTimestamp < latestTimestampForSender) {
+                            return;
+                          }
+          
+                          if (contentState !== false) {
+                            organizedChatReferences[item.chatReference].reactions[content].push(item);
+                          }
+          
+                          if (organizedChatReferences[item.chatReference].reactions[content].length === 0) {
+                            delete organizedChatReferences[item.chatReference].reactions[content];
+                          }
+                        } catch (error) {
+                          console.error("Error processing reaction item:", error, item);
+                        }
+                      });
+          
+                    return organizedChatReferences;
+                  });
+                } else {
+                  const formatted = combineUIAndExtensionMsgs
+                    .filter((rawItem) => !rawItem?.chatReference)
+                    .map((item) => ({
+                      ...item,
+                      id: item.signature,
+                      text: item?.decryptedData?.message || "",
+                      repliedTo: item?.repliedTo || item?.decryptedData?.repliedTo,
+                      isNotEncrypted: !!item?.messageText,
+                      unread: false,
+                    }));
+                  setMessages(formatted);
+          
+                  setChatReferences((prev) => {
+                    const organizedChatReferences = { ...prev };
+          
+                    combineUIAndExtensionMsgs
+                      .filter((rawItem) => rawItem && rawItem.chatReference && rawItem.decryptedData?.type === "reaction")
+                      .forEach((item) => {
+                        try {
+                          const content = item.decryptedData?.content;
+                          const sender = item.sender;
+                          const newTimestamp = item.timestamp;
+                          const contentState = item.decryptedData?.contentState;
+          
+                          if (!content || typeof content !== "string" || !sender || typeof sender !== "string" || !newTimestamp) {
+                            console.warn("Invalid content, sender, or timestamp in reaction data", item);
+                            return;
+                          }
+          
+                          organizedChatReferences[item.chatReference] = {
+                            ...(organizedChatReferences[item.chatReference] || {}),
+                            reactions: organizedChatReferences[item.chatReference]?.reactions || {},
+                          };
+          
+                          organizedChatReferences[item.chatReference].reactions[content] =
+                            organizedChatReferences[item.chatReference].reactions[content] || [];
+          
+                          let latestTimestampForSender = null;
+          
+                          organizedChatReferences[item.chatReference].reactions[content] = 
+                            organizedChatReferences[item.chatReference].reactions[content].filter((reaction) => {
+                              if (reaction.sender === sender) {
+                                latestTimestampForSender = Math.max(latestTimestampForSender || 0, reaction.timestamp);
+                              }
+                              return reaction.sender !== sender;
+                            });
+          
+                          if (latestTimestampForSender && newTimestamp < latestTimestampForSender) {
+                            return;
+                          }
+          
+                          if (contentState !== false) {
+                            organizedChatReferences[item.chatReference].reactions[content].push(item);
+                          }
+          
+                          if (organizedChatReferences[item.chatReference].reactions[content].length === 0) {
+                            delete organizedChatReferences[item.chatReference].reactions[content];
+                          }
+                        } catch (error) {
+                          console.error("Error processing reaction item:", error, item);
+                        }
+                      });
+          
+                    return organizedChatReferences;
+                  });
                 }
-              }), selectedGroup)
-              res(combineUIAndExtensionMsgs)
-              if(isInitiated){
-               
-                const formatted = combineUIAndExtensionMsgs.filter((rawItem)=> !rawItem?.chatReference).map((item: any)=> {
-                  return {
-                    ...item,
-                    id: item.signature,
-                    text: item?.decryptedData?.message || "",
-                    repliedTo: item?.repliedTo || item?.decryptedData?.repliedTo,
-                    unread: item?.sender === myAddress ? false : !!item?.chatReference ? false : true,
-                    isNotEncrypted: !!item?.messageText
-                  }
-                } )
-                setMessages((prev)=> [...prev, ...formatted])
-
-               
-                setChatReferences((prev) => {
-                  let organizedChatReferences = { ...prev };
-                
-                  combineUIAndExtensionMsgs
-                    .filter((rawItem) => rawItem && rawItem.chatReference && rawItem.decryptedData?.type === 'reaction')
-                    .forEach((item) => {
-                      try {
-                        const content = item.decryptedData?.content;
-                        const sender = item.sender;
-                        const newTimestamp = item.timestamp;
-                        const contentState = item.decryptedData?.contentState;
-                
-                        if (!content || typeof content !== 'string' || !sender || typeof sender !== 'string' || !newTimestamp) {
-                          console.warn("Invalid content, sender, or timestamp in reaction data", item);
-                          return;
-                        }
-                
-                        // Initialize chat reference and reactions if not present
-                        organizedChatReferences[item.chatReference] = {
-                          ...(organizedChatReferences[item.chatReference] || {}),
-                          reactions: organizedChatReferences[item.chatReference]?.reactions || {}
-                        };
-                
-                        organizedChatReferences[item.chatReference].reactions[content] =
-                          organizedChatReferences[item.chatReference].reactions[content] || [];
-                
-                        // Remove any existing reactions from the same sender before adding the new one
-                        let latestTimestampForSender = null;
-                
-                        // Track the latest reaction timestamp for the same content and sender
-                        organizedChatReferences[item.chatReference].reactions[content] =
-                          organizedChatReferences[item.chatReference].reactions[content].filter((reaction) => {
-                            if (reaction.sender === sender) {
-                              // Track the latest timestamp for this sender
-                              latestTimestampForSender = Math.max(latestTimestampForSender || 0, reaction.timestamp);
-                            }
-                            return reaction.sender !== sender;
-                          });
-                
-                        // Compare with the latest tracked timestamp for this sender
-                        if (latestTimestampForSender && newTimestamp < latestTimestampForSender) {
-                          // Ignore this item if it's older than the latest known reaction
-                          return;
-                        }
-                
-                        // Add the new reaction only if contentState is true
-                        if (contentState !== false) {
-                          organizedChatReferences[item.chatReference].reactions[content].push(item);
-                        }
-                
-                        // If the reactions for a specific content are empty, clean up the object
-                        if (organizedChatReferences[item.chatReference].reactions[content].length === 0) {
-                          delete organizedChatReferences[item.chatReference].reactions[content];
-                        }
-                      } catch (error) {
-                        console.error("Error processing reaction item:", error, item);
-                      }
-                    });
-                
-                  return organizedChatReferences;
-                });
-                
-                
-                
-              } else {
-                const formatted = combineUIAndExtensionMsgs.filter((rawItem)=> !rawItem?.chatReference).map((item: any)=> {
-                  return {
-                    ...item,
-                    id: item.signature,
-                    text: item?.decryptedData?.message || "",
-                    repliedTo: item?.repliedTo || item?.decryptedData?.repliedTo,
-                    isNotEncrypted: !!item?.messageText,
-                    unread:  false
-                  }
-                } )
-                setMessages(formatted)
-              
-                setChatReferences((prev) => {
-                  let organizedChatReferences = { ...prev };
-                
-                  combineUIAndExtensionMsgs
-                    .filter((rawItem) => rawItem && rawItem.chatReference && rawItem.decryptedData?.type === 'reaction')
-                    .forEach((item) => {
-                      try {
-                        const content = item.decryptedData?.content;
-                        const sender = item.sender;
-                        const newTimestamp = item.timestamp;
-                        const contentState = item.decryptedData?.contentState;
-                
-                        if (!content || typeof content !== 'string' || !sender || typeof sender !== 'string' || !newTimestamp) {
-                          console.warn("Invalid content, sender, or timestamp in reaction data", item);
-                          return;
-                        }
-                
-                        // Initialize chat reference and reactions if not present
-                        organizedChatReferences[item.chatReference] = {
-                          ...(organizedChatReferences[item.chatReference] || {}),
-                          reactions: organizedChatReferences[item.chatReference]?.reactions || {}
-                        };
-                
-                        organizedChatReferences[item.chatReference].reactions[content] =
-                          organizedChatReferences[item.chatReference].reactions[content] || [];
-                
-                        // Remove any existing reactions from the same sender before adding the new one
-                        let latestTimestampForSender = null;
-                
-                        // Track the latest reaction timestamp for the same content and sender
-                        organizedChatReferences[item.chatReference].reactions[content] =
-                          organizedChatReferences[item.chatReference].reactions[content].filter((reaction) => {
-                            if (reaction.sender === sender) {
-                              // Track the latest timestamp for this sender
-                              latestTimestampForSender = Math.max(latestTimestampForSender || 0, reaction.timestamp);
-                            }
-                            return reaction.sender !== sender;
-                          });
-                
-                        // Compare with the latest tracked timestamp for this sender
-                        if (latestTimestampForSender && newTimestamp < latestTimestampForSender) {
-                          // Ignore this item if it's older than the latest known reaction
-                          return;
-                        }
-                
-                        // Add the new reaction only if contentState is true
-                        if (contentState !== false) {
-                          organizedChatReferences[item.chatReference].reactions[content].push(item);
-                        }
-                
-                        // If the reactions for a specific content are empty, clean up the object
-                        if (organizedChatReferences[item.chatReference].reactions[content].length === 0) {
-                          delete organizedChatReferences[item.chatReference].reactions[content];
-                        }
-                      } catch (error) {
-                        console.error("Error processing reaction item:", error, item);
-                      }
-                    });
-                
-                  return organizedChatReferences;
-                });
-                
-                
-                
-                
-                
               }
-            }
+              rej(response.error);
-            rej(response.error)
+            })
-          });
+            .catch((error) => {
+              rej(error.message || "An error occurred");
+            });
+          
         })  
       } catch (error) {
           
@@ -418,17 +399,22 @@ export const ChatGroup = ({selectedGroup, secretKey, setSecretKey, getSecretKey,
   const encryptChatMessage = async (data: string, secretKeyObject: any, reactiontypeNumber?: number)=> {
     try {
       return new Promise((res, rej)=> {
-        chrome?.runtime?.sendMessage({ action: "encryptSingle", payload: {
+        window.sendMessage("encryptSingle", {
           data,
           secretKeyObject,
-          typeNumber: reactiontypeNumber
+          typeNumber: reactiontypeNumber,
-      }}, (response) => {
+        })
-     
+          .then((response) => {
-          if (!response?.error) {
+            if (!response?.error) {
-            res(response)
+              res(response);
-          }
+              return;
-          rej(response.error)
+            }
-        });
+            rej(response.error);
+          })
+          .catch((error) => {
+            rej(error.message || "An error occurred");
+          });
+        
       })  
     } catch (error) {
         

src/components/Chat/GroupAnnouncements.tsx

@@ -208,43 +208,42 @@ export const GroupAnnouncements = ({
   const encryptChatMessage = async (data: string, secretKeyObject: any) => {
     try {
       return new Promise((res, rej) => {
-        chrome?.runtime?.sendMessage(
+        window.sendMessage("encryptSingle", {
-          {
+          data,
-            action: "encryptSingle",
+          secretKeyObject,
-            payload: {
+        })
-              data,
+          .then((response) => {
-              secretKeyObject,
-            },
-          },
-          (response) => {
             if (!response?.error) {
               res(response);
               return;
             }
             rej(response.error);
-          }
+          })
-        );
+          .catch((error) => {
+            rej(error.message || "An error occurred");
+          });
+        
       });
     } catch (error) {}
   };
 
   const publishAnc = async ({ encryptedData, identifier }: any) => {
     return new Promise((res, rej) => {
-      chrome?.runtime?.sendMessage(
+      window.sendMessage("publishGroupEncryptedResource", {
-        {
+        encryptedData,
-          action: "publishGroupEncryptedResource",
+        identifier,
-          payload: {
+      })
-            encryptedData,
+        .then((response) => {
-            identifier,
-          },
-        },
-        (response) => {
           if (!response?.error) {
             res(response);
+            return;
           }
           rej(response.error);
-        }
+        })
-      );
+        .catch((error) => {
+          rej(error.message || "An error occurred");
+        });
+      
     });
   };
   const clearEditorContent = () => {

src/components/Group/Forum/GroupMail.tsx

@@ -145,22 +145,23 @@ export const GroupMail = ({
   const updateThreadActivity = async ({threadId, qortalName, groupId, thread}) => {
     try {
       await new Promise((res, rej) => {
-        chrome?.runtime?.sendMessage(
+        window.sendMessage("updateThreadActivity", {
-          {
+          threadId,
-            action: "updateThreadActivity",
+          qortalName,
-            payload: {
+          groupId,
-              threadId, qortalName, groupId, thread
+          thread,
-            },
+        })
-          },
+          .then((response) => {
-          (response) => {
-        
             if (!response?.error) {
               res(response);
-              return
+              return;
             }
             rej(response.error);
-          }
+          })
-        );
+          .catch((error) => {
+            rej(error.message || "An error occurred");
+          });
+        
       });
       
     } catch (error) {

src/components/Group/Forum/NewThread.tsx

@@ -94,46 +94,42 @@ export const publishGroupEncryptedResource = async ({
   identifier,
 }) => {
   return new Promise((res, rej) => {
-    chrome?.runtime?.sendMessage(
+    window.sendMessage("publishGroupEncryptedResource", {
-      {
+      encryptedData,
-        action: "publishGroupEncryptedResource",
+      identifier,
-        payload: {
+    })
-          encryptedData,
+      .then((response) => {
-          identifier,
-        },
-      },
-      (response) => {
-    
         if (!response?.error) {
           res(response);
-          return
+          return;
         }
         rej(response.error);
-      }
+      })
-    );
+      .catch((error) => {
+        rej(error.message || "An error occurred");
+      });
+    
   });
 };
 
 export const encryptSingleFunc = async (data: string, secretKeyObject: any) => {
   try {
     return new Promise((res, rej) => {
-      chrome?.runtime?.sendMessage(
+      window.sendMessage("encryptSingle", {
-        {
+        data,
-          action: "encryptSingle",
+        secretKeyObject,
-          payload: {
+      })
-            data,
+        .then((response) => {
-            secretKeyObject,
-          },
-        },
-        (response) => {
-        
           if (!response?.error) {
             res(response);
             return;
           }
           rej(response.error);
-        }
+        })
-      );
+        .catch((error) => {
+          rej(error.message || "An error occurred");
+        });
+      
     });
   } catch (error) {}
 };

src/components/Group/Group.tsx

@@ -199,21 +199,20 @@ export const getGroupMembers = async (groupNumber: number) => {
 export const decryptResource = async (data: string) => {
   try {
     return new Promise((res, rej) => {
-      chrome?.runtime?.sendMessage(
+      window.sendMessage("decryptGroupEncryption", {
-        {
+        data,
-          action: "decryptGroupEncryption",
+      })
-          payload: {
+        .then((response) => {
-            data,
-          },
-        },
-        (response) => {
           if (!response?.error) {
             res(response);
             return;
           }
           rej(response.error);
-        }
+        })
-      );
+        .catch((error) => {
+          rej(error.message || "An error occurred");
+        });
+      
     });
   } catch (error) {}
 };

src/components/Group/ListOfThreadPostsWatched.tsx

@@ -24,34 +24,33 @@ export const ListOfThreadPostsWatched = () => {
   const getPosts = async () => {
     try {
       await new Promise((res, rej) => {
-        chrome?.runtime?.sendMessage(
+        window.sendMessage("getThreadActivity", {})
-          {
+        .then((response) => {
-            action: "getThreadActivity",
+          if (!response?.error) {
-            payload: {},
+            if (!response) {
-          },
+              res(null);
-          (response) => {
-            if (!response?.error) {
-              if (!response) {
-                res(null);
-                return;
-              }
-              const uniquePosts = response.reduce((acc, current) => {
-                const x = acc.find(
-                  (item) => item?.thread?.threadId === current?.thread?.threadId
-                );
-                if (!x) {
-                  return acc.concat([current]);
-                } else {
-                  return acc;
-                }
-              }, []);
-              setPosts(uniquePosts);
-              res(uniquePosts);
               return;
             }
-            rej(response.error);
+            const uniquePosts = response.reduce((acc, current) => {
+              const x = acc.find(
+                (item) => item?.thread?.threadId === current?.thread?.threadId
+              );
+              if (!x) {
+                return acc.concat([current]);
+              } else {
+                return acc;
+              }
+            }, []);
+            setPosts(uniquePosts);
+            res(uniquePosts);
+            return;
           }
-        );
+          rej(response.error);
+        })
+        .catch((error) => {
+          rej(error.message || "An error occurred");
+        });
+      
       });
     } catch (error) {
     } finally {

src/components/Group/WebsocketActive.tsx

@@ -74,13 +74,13 @@ export const WebSocketActive = ({ myAddress, setIsLoadingGroups }) => {
               ).sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
 
            
-              chrome?.runtime?.sendMessage({
+              window.sendMessage("handleActiveGroupDataFromSocket", {
-                action: 'handleActiveGroupDataFromSocket',
+                groups: sortedGroups,
-                payload: {
+                directs: sortedDirects,
-                  groups: sortedGroups,
+              }).catch((error) => {
-                  directs: sortedDirects,
+                  console.error("Failed to handle active group data from socket:", error.message || "An error occurred");
-                },
+                });
-              });
+              
             }
           } catch (error) {
             console.error('Error parsing onmessage data:', error);

src/components/MainAvatar.tsx

@@ -63,24 +63,22 @@ const [isLoading, setIsLoading] = useState(false)
             setIsLoading(true);
             const avatarBase64 = await fileToBase64(avatarFile)
             await new Promise((res, rej) => {
-                chrome?.runtime?.sendMessage(
+              window.sendMessage("publishOnQDN", {
-                  {
+                data: avatarBase64,
-                    action: "publishOnQDN",
+                identifier: "qortal_avatar",
-                    payload: {
+                service: "THUMBNAIL",
-                      data: avatarBase64,
+              })
-                      identifier: "qortal_avatar",
+                .then((response) => {
-                      service: 'THUMBNAIL'
+                  if (!response?.error) {
-                    },
+                    res(response);
-                  },
+                    return;
-                  (response) => {
-                 
-                    if (!response?.error) {
-                      res(response);
-                      return
-                    }
-                    rej(response.error);
                   }
-                );
+                  rej(response.error);
+                })
+                .catch((error) => {
+                  rej(error.message || "An error occurred");
+                });
+              
               });
         setAvatarFile(null);
         setTempAvatar(`data:image/webp;base64,${avatarBase64}`)

src/components/Save/Save.tsx

@@ -87,24 +87,22 @@ export const Save = ({isDesktop}) => {
             publishFee: fee.fee + ' QORT'
           })
          const response =  await new Promise((res, rej) => {
-            chrome?.runtime?.sendMessage(
+          window.sendMessage("publishOnQDN", {
-              {
+            data: encryptData,
-                action: "publishOnQDN",
+            identifier: "ext_saved_settings",
-                payload: {
+            service: "DOCUMENT_PRIVATE",
-                  data: encryptData,
+          })
-                  identifier: "ext_saved_settings",
+            .then((response) => {
-                  service: 'DOCUMENT_PRIVATE'
+              if (!response?.error) {
-                },
+                res(response);
-              },
+                return;
-              (response) => {
-             
-                if (!response?.error) {
-                  res(response);
-                  return
-                }
-                rej(response.error);
               }
-            );
+              rej(response.error);
+            })
+            .catch((error) => {
+              rej(error.message || "An error occurred");
+            });
+          
           });
           if(response?.identifier){
             setOldPinnedApps(pinnedApps)