diff --git a/src/background-cases.ts b/src/background-cases.ts index d4e2af2..700bdf7 100644 --- a/src/background-cases.ts +++ b/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 + ); + } + } \ No newline at end of file diff --git a/src/background.ts b/src/background.ts index bd74741..4eb8963 100644 --- a/src/background.ts +++ b/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": - encryptAndPublishSymmetricKeyGroupChatCase(request, event); + case "encryptAndPublishSymmetricKeyGroupChat": + 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 } }); } diff --git a/src/components/Apps/AppPublish.tsx b/src/components/Apps/AppPublish.tsx index 9736bfe..76bde28 100644 --- a/src/components/Apps/AppPublish.tsx +++ b/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( - { - action: "publishOnQDN", - payload: { - data: fileBase64, - service: appType, - title, - description, - category, - tag1, - tag2, - tag3, - tag4, - tag5, - uploadType: 'zip' - }, - }, - (response) => { + window.sendMessage("publishOnQDN", { + data: fileBase64, + service: appType, + title, + description, + category, + tag1, + tag2, + tag3, + tag4, + tag5, + uploadType: "zip", + }) + .then((response) => { if (!response?.error) { res(response); return; } rej(response.error); - } - ); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }); setInfoSnack({ type: "success", diff --git a/src/components/Chat/AnnouncementDiscussion.tsx b/src/components/Chat/AnnouncementDiscussion.tsx index 286ce95..cc6af24 100644 --- a/src/components/Chat/AnnouncementDiscussion.tsx +++ b/src/components/Chat/AnnouncementDiscussion.tsx @@ -75,23 +75,21 @@ export const AnnouncementDiscussion = ({ if (!selectedAnnouncement) return; return new Promise((res, rej) => { - chrome?.runtime?.sendMessage( - { - action: "publishGroupEncryptedResource", - payload: { - encryptedData, - identifier, - }, - }, - (response) => { - + window.sendMessage("publishGroupEncryptedResource", { + encryptedData, + identifier, + }) + .then((response) => { if (!response?.error) { res(response); - return + return; } rej(response.error); - } - ); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }); } catch (error) {} }; diff --git a/src/components/Chat/ChatGroup.tsx b/src/components/Chat/ChatGroup.tsx index 0cf2cc6..547602a 100644 --- a/src/components/Chat/ChatGroup.tsx +++ b/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 - }}, (response) => { - if (!response?.error) { - const filterUImessages = encryptedMessages.filter((item)=> !isExtMsg(item.data)) - const decodedUIMessages = decodeBase64ForUIChatMessages(filterUImessages) - - const combineUIAndExtensionMsgs = [...decodedUIMessages, ...response] - processWithNewMessages(combineUIAndExtensionMsgs?.map((item)=> { - return { - ...item, - ...(item?.decryptedData || {}) + secretKeyObject: secretKey, + }) + .then((response) => { + if (!response?.error) { + const filterUIMessages = encryptedMessages.filter((item) => !isExtMsg(item.data)); + const decodedUIMessages = decodeBase64ForUIChatMessages(filterUIMessages); + + const combineUIAndExtensionMsgs = [...decodedUIMessages, ...response]; + processWithNewMessages( + combineUIAndExtensionMsgs.map((item) => ({ + ...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 - }}, (response) => { - - if (!response?.error) { - res(response) - } - rej(response.error) - }); + typeNumber: reactiontypeNumber, + }) + .then((response) => { + if (!response?.error) { + res(response); + return; + } + rej(response.error); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }) } catch (error) { diff --git a/src/components/Chat/GroupAnnouncements.tsx b/src/components/Chat/GroupAnnouncements.tsx index f573101..d1591b6 100644 --- a/src/components/Chat/GroupAnnouncements.tsx +++ b/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( - { - action: "encryptSingle", - payload: { - data, - secretKeyObject, - }, - }, - (response) => { + window.sendMessage("encryptSingle", { + data, + secretKeyObject, + }) + .then((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( - { - action: "publishGroupEncryptedResource", - payload: { - encryptedData, - identifier, - }, - }, - (response) => { + window.sendMessage("publishGroupEncryptedResource", { + encryptedData, + identifier, + }) + .then((response) => { if (!response?.error) { res(response); + return; } rej(response.error); - } - ); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }); }; const clearEditorContent = () => { diff --git a/src/components/Group/Forum/GroupMail.tsx b/src/components/Group/Forum/GroupMail.tsx index 36fefad..9d2e42d 100644 --- a/src/components/Group/Forum/GroupMail.tsx +++ b/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( - { - action: "updateThreadActivity", - payload: { - threadId, qortalName, groupId, thread - }, - }, - (response) => { - + window.sendMessage("updateThreadActivity", { + threadId, + qortalName, + groupId, + thread, + }) + .then((response) => { if (!response?.error) { res(response); - return + return; } rej(response.error); - } - ); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }); } catch (error) { diff --git a/src/components/Group/Forum/NewThread.tsx b/src/components/Group/Forum/NewThread.tsx index 9aa67d8..b6cbf89 100644 --- a/src/components/Group/Forum/NewThread.tsx +++ b/src/components/Group/Forum/NewThread.tsx @@ -94,46 +94,42 @@ export const publishGroupEncryptedResource = async ({ identifier, }) => { return new Promise((res, rej) => { - chrome?.runtime?.sendMessage( - { - action: "publishGroupEncryptedResource", - payload: { - encryptedData, - identifier, - }, - }, - (response) => { - + window.sendMessage("publishGroupEncryptedResource", { + encryptedData, + identifier, + }) + .then((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( - { - action: "encryptSingle", - payload: { - data, - secretKeyObject, - }, - }, - (response) => { - + window.sendMessage("encryptSingle", { + data, + secretKeyObject, + }) + .then((response) => { if (!response?.error) { res(response); return; } rej(response.error); - } - ); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }); } catch (error) {} }; diff --git a/src/components/Group/Group.tsx b/src/components/Group/Group.tsx index 10ec158..d6f95da 100644 --- a/src/components/Group/Group.tsx +++ b/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( - { - action: "decryptGroupEncryption", - payload: { - data, - }, - }, - (response) => { + window.sendMessage("decryptGroupEncryption", { + data, + }) + .then((response) => { if (!response?.error) { res(response); return; } rej(response.error); - } - ); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }); } catch (error) {} }; diff --git a/src/components/Group/ListOfThreadPostsWatched.tsx b/src/components/Group/ListOfThreadPostsWatched.tsx index 4817805..06e13de 100644 --- a/src/components/Group/ListOfThreadPostsWatched.tsx +++ b/src/components/Group/ListOfThreadPostsWatched.tsx @@ -24,34 +24,33 @@ export const ListOfThreadPostsWatched = () => { const getPosts = async () => { try { await new Promise((res, rej) => { - chrome?.runtime?.sendMessage( - { - action: "getThreadActivity", - payload: {}, - }, - (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); + window.sendMessage("getThreadActivity", {}) + .then((response) => { + if (!response?.error) { + if (!response) { + res(null); 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 { diff --git a/src/components/Group/WebsocketActive.tsx b/src/components/Group/WebsocketActive.tsx index 33a6dca..0498ff2 100644 --- a/src/components/Group/WebsocketActive.tsx +++ b/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({ - action: 'handleActiveGroupDataFromSocket', - payload: { - groups: sortedGroups, - directs: sortedDirects, - }, - }); + window.sendMessage("handleActiveGroupDataFromSocket", { + groups: sortedGroups, + directs: sortedDirects, + }).catch((error) => { + console.error("Failed to handle active group data from socket:", error.message || "An error occurred"); + }); + } } catch (error) { console.error('Error parsing onmessage data:', error); diff --git a/src/components/MainAvatar.tsx b/src/components/MainAvatar.tsx index 71aed3b..b5f8e44 100644 --- a/src/components/MainAvatar.tsx +++ b/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( - { - action: "publishOnQDN", - payload: { - data: avatarBase64, - identifier: "qortal_avatar", - service: 'THUMBNAIL' - }, - }, - (response) => { - - if (!response?.error) { - res(response); - return - } - rej(response.error); + window.sendMessage("publishOnQDN", { + data: avatarBase64, + identifier: "qortal_avatar", + service: "THUMBNAIL", + }) + .then((response) => { + if (!response?.error) { + res(response); + return; } - ); + rej(response.error); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }); setAvatarFile(null); setTempAvatar(`data:image/webp;base64,${avatarBase64}`) diff --git a/src/components/Save/Save.tsx b/src/components/Save/Save.tsx index e00bd08..7d94ec0 100644 --- a/src/components/Save/Save.tsx +++ b/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( - { - action: "publishOnQDN", - payload: { - data: encryptData, - identifier: "ext_saved_settings", - service: 'DOCUMENT_PRIVATE' - }, - }, - (response) => { - - if (!response?.error) { - res(response); - return - } - rej(response.error); + window.sendMessage("publishOnQDN", { + data: encryptData, + identifier: "ext_saved_settings", + service: "DOCUMENT_PRIVATE", + }) + .then((response) => { + if (!response?.error) { + res(response); + return; } - ); + rej(response.error); + }) + .catch((error) => { + rej(error.message || "An error occurred"); + }); + }); if(response?.identifier){ setOldPinnedApps(pinnedApps)