Qortal/qortal-mobile
1
0
Fork 0
mirror of https://github.com/Qortal/qortal-mobile.git synced 2025-06-03 15:07:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

cases

Browse Source
This commit is contained in:
PhilReact 2024-10-29 06:49:25 +02:00
parent cbd372bc07
commit 4da55da54e
13 changed files with 603 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

236
src/background-cases.ts
View File

@ -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
);
}
}

49
src/background.ts
View File

@ -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
}
});
}

39
src/components/Apps/AppPublish.tsx
View File

@ -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",

24
src/components/Chat/AnnouncementDiscussion.tsx
View File

@ -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) {}
};

354
src/components/Chat/ChatGroup.tsx
View File

@ -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) {

43
src/components/Chat/GroupAnnouncements.tsx
View File

@ -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 = () => {

25
src/components/Group/Forum/GroupMail.tsx
View File

@ -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) {

46
src/components/Group/Forum/NewThread.tsx
View File

@ -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) {}
};

19
src/components/Group/Group.tsx
View File

@ -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) {}
};

49
src/components/Group/ListOfThreadPostsWatched.tsx
View File

@ -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 {

14
src/components/Group/WebsocketActive.tsx
View File

@ -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);

32
src/components/MainAvatar.tsx
View File

@ -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}`)

32
src/components/Save/Save.tsx
View File

@ -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)