@secrecy/lib 1.77.0 → 1.79.0

package/dist/lib/client/SecrecyCloudClient.js

@@ -20,16 +20,17 @@ export class SecrecyCloudClient {
         const addDataToHistory = await this.#client.apiClient.cloud.addDataToHistory.mutate({
             dataId,
             nodeId,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         const node = await apiNodeFullToInternalFull(addDataToHistory, this.#client.keyPairs);
         const data = node.history.find((d) => d.id === dataId);
         if (data !== undefined) {
-            const othersIdentities = Object.entries(node.identities).filter(([id]) => id !== this.#client.uaIdentity.identityPubKey);
+            const othersIdentities = Object.entries(node.identities).filter(([id]) => id !== this.#client.currentIdentity.identityPubKey);
             const shares = othersIdentities.map(([publicKey]) => {
                 return {
                     pubKey: publicKey,
                     key: data.key
-                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#client.uaPrivateKey))
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#client.currentIdentityPrivateKey))
                         : null,
                 };
             });
@@ -37,6 +38,7 @@ export class SecrecyCloudClient {
                 dataId: data.id,
                 nodeId,
                 users: shares,
+                fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
             });
         }
         return internalNodeFullToNodeFull(node);
@@ -44,7 +46,7 @@ export class SecrecyCloudClient {
     async uploadData(opts) {
         return uploadData({
             ...opts,
-            uaIdentity: this.#client.uaIdentity,
+            currentIdentity: this.#client.currentIdentity,
             keyPairs: this.#client.keyPairs,
             apiClient: this.#client.apiClient,
         });
@@ -60,21 +62,29 @@ export class SecrecyCloudClient {
         return await this.saveInCloud({ dataId: uploadedData.id, name, nodeId });
     }
     async deletedNodes() {
-        const deletedNodes = await this.#client.apiClient.cloud.nodesDeleted.query({});
+        const deletedNodes = await this.#client.apiClient.cloud.nodesDeleted.query({
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return await Promise.all(deletedNodes.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
     async sharedNodes() {
-        const nodesShared = await this.#client.apiClient.cloud.nodesShared.query({});
+        const nodesShared = await this.#client.apiClient.cloud.nodesShared.query({
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return await Promise.all(nodesShared.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
     async nodesSharedWithMe(type = 'FOLDER') {
-        const nodesSharedWithMe = await this.#client.apiClient.cloud.nodesSharedWithMe.query({ type });
+        const nodesSharedWithMe = await this.#client.apiClient.cloud.nodesSharedWithMe.query({
+            type,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return await Promise.all(nodesSharedWithMe.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
     async deleteNodeSharing({ nodeId, destPubKey, }) {
         const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeSharing.mutate({
             nodeId,
             destPubKey,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isDeleted;
     }
@@ -82,6 +92,7 @@ export class SecrecyCloudClient {
         const { isDeleted } = await this.#client.apiClient.cloud.leaveSharing.mutate({
             nodeId,
             fromPubKey,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isDeleted;
     }
@@ -105,27 +116,32 @@ export class SecrecyCloudClient {
             nodeId,
             folderId: folderId ?? null,
             name,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isDuplicated;
     }
     async deleteNodeCloudTrash({ ids }) {
-        const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeCloudTrash.mutate({ ids });
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeCloudTrash.mutate({
+            ids,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return isDeleted;
     }
     async createFolder({ name, parentFolderId, }) {
         const { encryptedNameKey, encryptedName } = await generateAndEncryptNameAndKey({
             name,
-            privateKey: this.#client.uaPrivateKey,
-            publicKey: this.#client.uaIdentity.identityPubKey,
+            privateKey: this.#client.currentIdentityPrivateKey,
+            publicKey: this.#client.currentIdentity.identityPubKey,
         });
         const createdFolder = await this.#client.apiClient.cloud.createFolder.mutate({
             name: encryptedName,
             parentId: parentFolderId ?? null,
             nameKey: encryptedNameKey,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         const folder = await apiNodeToExternalNodeFull(createdFolder, this.#client.keyPairs);
         if (folder.parent) {
-            const othersIdentities = Object.entries(folder.parent.identities).filter(([id]) => id !== this.#client.uaIdentity.identityPubKey);
+            const othersIdentities = Object.entries(folder.parent.identities).filter(([id]) => id !== this.#client.currentIdentity.identityPubKey);
             // TODO: ??
             if (othersIdentities.length > 0) {
                 await this.shareNode(othersIdentities.map(([identityPubKey, permissions]) => ({
@@ -145,17 +161,30 @@ export class SecrecyCloudClient {
         const node = await this.#client.apiClient.cloud.nodeFullById.query({
             id,
             deleted,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return await apiNodeToExternalNodeFull(node, this.#client.keyPairs);
     }
+    async nodes({ ids, deleted, }) {
+        const nodes = await this.#client.apiClient.cloud.nodeFullByIds.query({
+            ids,
+            deleted,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
+        return await Promise.all(nodes.nodes.map((node) => apiNodeToExternalNodeFull(node, this.#client.keyPairs)));
+    }
     async dataMetadata({ id }) {
-        const data = await this.#client.apiClient.cloud.dataById.query({ id });
+        const data = await this.#client.apiClient.cloud.dataById.query({
+            id,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return apiDataToExternal(data, this.#client.keyPairs);
     }
     async shareNode(accesses, progress) {
         // TODO: Validate input
         const nodesMap = await this.#client.apiClient.cloud.shareNode.mutate({
             accesses,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         const maxNodesBatchSize = 1000;
         const totalNodesToShare = Object.values(nodesMap).reduce((size, ids) => size + ids.length, 0);
@@ -235,6 +264,7 @@ export class SecrecyCloudClient {
             const subState = finishInput.length > 0
                 ? await this.#client.apiClient.cloud.shareNodeFinish.mutate({
                     accesses: finishInput,
+                    fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
                 })
                 : { isFinished: true, details: {} };
             const currentProgress = Math.min((index + 1) * maxNodesBatchSize, totalNodesToShare);
@@ -298,6 +328,7 @@ export class SecrecyCloudClient {
             id: nodeId,
             isFavorite: isFavorite ?? null,
             name,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return await apiNodeToExternalNodeFull(updateNode, this.#client.keyPairs);
     }
@@ -308,6 +339,7 @@ export class SecrecyCloudClient {
         }
         const dataContent = await this.#client.apiClient.cloud.dataContentById.query({
             id: dataId,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         const totalBytes = Number(dataContent.sizeEncrypted ?? dataContent.size);
         const progressParts = {};
@@ -329,6 +361,7 @@ export class SecrecyCloudClient {
         }
         const missingContents = await this.#client.apiClient.cloud.dataContentByIds.query({
             ids: dataIds.filter((dataId) => !cachedData.some((datum) => datum.id === dataId)),
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         const allDataContents = [
             ...missingContents.map((data) => ({
@@ -358,28 +391,36 @@ export class SecrecyCloudClient {
         }));
     }
     async deleteNodes({ nodeIds, }) {
-        return this.#client.apiClient.cloud.deleteNodes.mutate({ ids: nodeIds });
+        return this.#client.apiClient.cloud.deleteNodes.mutate({
+            ids: nodeIds,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
     }
     async deleteData({ dataId, nodeId, }) {
         const { isDeleted } = await this.#client.apiClient.cloud.deleteData.mutate({
             dataId,
             nodeId,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isDeleted;
     }
     async deleteNode({ nodeId }) {
         const { isDeleted } = await this.#client.apiClient.cloud.deleteNode.mutate({
             id: nodeId,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isDeleted;
     }
     async emptyTrash() {
-        const { isCleaned } = await this.#client.apiClient.cloud.emptyNodeCloudTrash.mutate({});
+        const { isCleaned } = await this.#client.apiClient.cloud.emptyNodeCloudTrash.mutate({
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return isCleaned;
     }
     async recoverNode(id) {
         const { isRecovered } = await this.#client.apiClient.cloud.recoverNode.mutate({
             id,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isRecovered;
     }
@@ -387,6 +428,7 @@ export class SecrecyCloudClient {
         const { isMoved } = await this.#client.apiClient.cloud.moveNodes.mutate({
             ids: nodeIds,
             parentId: parentNodeId ?? null,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isMoved;
     }
@@ -429,7 +471,7 @@ export class SecrecyCloudClient {
                 }
                 const senderPubKey = await this.#client.app.userPublicKey(mail.sender.id);
                 const dataKey = attachment.key
-                    ? decryptCryptoBox(sodium.from_hex(attachment.key), senderPubKey, this.#client.uaPrivateKey)
+                    ? decryptCryptoBox(sodium.from_hex(attachment.key), senderPubKey, this.#client.currentIdentityPrivateKey)
                     : null;
                 key = dataKey !== null ? sodium.to_hex(dataKey) : null;
             }
@@ -441,12 +483,12 @@ export class SecrecyCloudClient {
             key = data.key;
         }
         key = key
-            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey))
+            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey))
             : null;
         const { encryptedNameKey, encryptedName } = await generateAndEncryptNameAndKey({
             name,
-            privateKey: this.#client.uaPrivateKey,
-            publicKey: this.#client.uaIdentity.identityPubKey,
+            privateKey: this.#client.currentIdentityPrivateKey,
+            publicKey: this.#client.currentIdentity.identityPubKey,
         });
         const saveInCloud = await this.#client.apiClient.cloud.saveInCloud.mutate({
             dataId,
@@ -454,10 +496,11 @@ export class SecrecyCloudClient {
             nodeId: nodeId ?? null,
             fileName: encryptedName,
             nameKey: encryptedNameKey,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         const node = await apiNodeToExternalNodeFull(saveInCloud, this.#client.keyPairs);
         if (node.parent) {
-            const othersIdentities = Object.entries(node.parent.identities).filter(([id]) => id !== this.#client.uaIdentity.identityPubKey);
+            const othersIdentities = Object.entries(node.parent.identities).filter(([id]) => id !== this.#client.currentIdentity.identityPubKey);
             // TODO: ??
             if (othersIdentities.length > 0) {
                 await this.shareNode(othersIdentities.map(([identityPubKey, permissions]) => ({
@@ -508,6 +551,7 @@ export class SecrecyCloudClient {
         const fetchedNodes = missingNodeIds.length > 0
             ? await this.#client.apiClient.cloud.nodesForEncryption.query({
                 ids: missingNodeIds,
+                fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
             })
             : [];
         const diff = missingNodeIds.filter((id) => !fetchedNodes.some((node) => node.id === id));
@@ -532,10 +576,10 @@ export class SecrecyCloudClient {
                 }
                 nodesMappedUsers[pubKey].push({
                     id: node.id,
-                    nameKey: sodium.to_hex(encryptCryptoBox(sodium.from_hex(node.access.nameKey), pubKey, this.#client.uaPrivateKey)),
+                    nameKey: sodium.to_hex(encryptCryptoBox(sodium.from_hex(node.access.nameKey), pubKey, this.#client.currentIdentityPrivateKey)),
                     data: node.history.map((f) => ({
                         id: f.id,
-                        key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), pubKey, this.#client.uaPrivateKey)),
+                        key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), pubKey, this.#client.currentIdentityPrivateKey)),
                     })),
                 });
             }
@@ -575,7 +619,10 @@ export class SecrecyCloudClient {
         return this.#client.apiClient.cloud.dataLinks.query(input);
     }
     checkAccesses(input) {
-        return this.#client.apiClient.cloud.checkAccesses.query(input);
+        return this.#client.apiClient.cloud.checkAccesses.query({
+            ...input,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
     }
     createPublicDataLink(input) {
         if (input.expireAt && input.expireAt <= new Date()) {
@@ -609,7 +656,7 @@ export class SecrecyCloudClient {
                 ? dataContent.senderPublicKey
                 : dataContent.type === 'cloud' || dataContent.type === 'lite'
                     ? dataContent.sharedByPublicKey
-                    : this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)
+                    : this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey)
             : null;
         const src = key
             ? await decrypt(key, encryptedContent, progressDecrypt, signal)

package/dist/lib/client/SecrecyGroupClient.js

@@ -12,21 +12,25 @@ export class SecrecyGroupClient {
         const opts = {
             pubKey: input.pubKey,
             role: input.role,
-            fromPubKey: this.#client.uaIdentity.identityPubKey,
             id: input.id,
-            encPriv: sodium.to_hex(encryptCryptoBox(sodium.from_hex(groupIdentity.identityPubKey), input.pubKey, this.#client.uaPrivateKey)),
+            encPriv: sodium.to_hex(encryptCryptoBox(sodium.from_hex(groupIdentity.identityPubKey), input.pubKey, this.#client.currentIdentityPrivateKey)),
         };
-        return this.#client.apiClient.group.addMember.mutate(opts);
+        return this.#client.apiClient.group.addMember.mutate({
+            ...opts,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
     }
     async create(input) {
         const keyPair = generateCryptoBoxKeyPair();
         const opts = {
             name: input.name,
-            fromPubKey: this.#client.uaIdentity.identityPubKey,
             pubKey: keyPair.publicKey,
-            encPriv: sodium.to_hex(encryptCryptoBox(sodium.from_hex(keyPair.privateKey), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)),
+            encPriv: sodium.to_hex(encryptCryptoBox(sodium.from_hex(keyPair.privateKey), this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey)),
         };
-        return this.#client.apiClient.group.create.mutate(opts);
+        return this.#client.apiClient.group.create.mutate({
+            ...opts,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
     }
     async deleteMember(input) {
         return this.#client.apiClient.group.deleteMember.mutate(input);

package/dist/lib/client/SecrecyMailClient.js

@@ -16,12 +16,14 @@ export class SecrecyMailClient {
     async recover({ mailId }) {
         const { isRecovered } = await this.#client.apiClient.mail.recover.mutate({
             id: mailId,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isRecovered;
     }
     async deletedMails({ mailType, }) {
         const deletedMails = await this.#client.apiClient.mail.deleted.query({
             type: mailType,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return await Promise.all(deletedMails.map(async (mail) => await convertInternalMailToExternal({
             mail,
@@ -73,7 +75,7 @@ export class SecrecyMailClient {
                         throw new Error(`File ${f.name} (${f.id}) does not exists`);
                     }
                 }
-                f.name = sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey));
+                f.name = sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey));
             }
         }
         const updateDraftMail = await this.#client.apiClient.mail.updateDraft.mutate({
@@ -81,14 +83,15 @@ export class SecrecyMailClient {
             recipients: recipients ?? null,
             replyToId: replyToId ?? null,
             body: body !== undefined
-                ? sodium.to_hex(encryptCryptoBox(sodium.from_string(body), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey))
+                ? sodium.to_hex(encryptCryptoBox(sodium.from_string(body), this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey))
                 : null,
             subject: subject !== undefined
-                ? sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey))
+                ? sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey))
                 : null,
             senderFiles: senderFiles ?? null,
             hash,
             hashKey,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return (await convertInternalMailToExternal({
             mail: updateDraftMail,
@@ -104,16 +107,20 @@ export class SecrecyMailClient {
     async deleteTrash({ ids }) {
         const { isDeleted } = await this.#client.apiClient.mail.deleteTrash.mutate({
             ids,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isDeleted;
     }
     async emptyTrash() {
-        const { isDeleted } = await this.#client.apiClient.mail.emptyTrash.mutate({});
+        const { isDeleted } = await this.#client.apiClient.mail.emptyTrash.mutate({
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return isDeleted;
     }
     async delete({ mailId }) {
         const { isDeleted } = await this.#client.apiClient.mail.delete.mutate({
             id: mailId,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isDeleted;
     }
@@ -201,17 +208,18 @@ export class SecrecyMailClient {
             }
             senderFiles.push({
                 id: data.id,
-                name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)),
+                name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey)),
             });
         }
         const createDraftMail = await this.#client.apiClient.mail.createDraft.mutate({
             recipients,
             replyToId,
-            body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)),
-            subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)),
+            body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey)),
+            subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), this.#client.currentIdentity.identityPubKey, this.#client.currentIdentityPrivateKey)),
             senderFiles,
             hash,
             hashKey,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return (await convertInternalMailToExternal({
             mail: createDraftMail,
@@ -221,17 +229,22 @@ export class SecrecyMailClient {
     async read({ mailId }) {
         const { isRead } = await this.#client.apiClient.mail.read.mutate({
             id: mailId,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isRead;
     }
     async unread({ mailId }) {
         const { isUnread } = await this.#client.apiClient.mail.unread.mutate({
             id: mailId,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
         return isUnread;
     }
     async receivedMails(input) {
-        const receivedMails = await this.#client.apiClient.mail.received.query(input);
+        const receivedMails = await this.#client.apiClient.mail.received.query({
+            ...input,
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return await Promise.all(receivedMails.map(async (mail) => (await convertInternalMailToExternal({
             mail,
             keyPairs: this.#client.keyPairs,
@@ -252,7 +265,9 @@ export class SecrecyMailClient {
         }))));
     }
     async unreadReceivedMailsCount() {
-        const unreadReceivedMailsCount = await this.#client.apiClient.mail.unreadReceivedCount.query({});
+        const unreadReceivedMailsCount = await this.#client.apiClient.mail.unreadReceivedCount.query({
+            fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
+        });
         return unreadReceivedMailsCount;
     }
     _eachUser = async (data, subject, body, idOrMail) => {
@@ -272,17 +287,17 @@ export class SecrecyMailClient {
             const key = dataInHistory.key;
             attachments.push({
                 dataId: f.id,
-                name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), pubKey, this.#client.uaPrivateKey)),
+                name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), pubKey, this.#client.currentIdentityPrivateKey)),
                 key: key
-                    ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), pubKey, this.#client.uaPrivateKey))
+                    ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), pubKey, this.#client.currentIdentityPrivateKey))
                     : null,
             });
         }
         return {
             // recipientId: userId,
             recipientPubKey: pubKey,
-            body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), pubKey, this.#client.uaPrivateKey)),
-            subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), pubKey, this.#client.uaPrivateKey)),
+            body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), pubKey, this.#client.currentIdentityPrivateKey)),
+            subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), pubKey, this.#client.currentIdentityPrivateKey)),
             attachments,
         };
     };

package/dist/lib/client/index.js

@@ -15,6 +15,7 @@ import { SecrecyIdentityClient } from './SecrecyIdentityClient.js';
 export class SecrecyClient extends BaseClient {
     #groupIdentities;
     #uaIdentity;
+    #currentGroupIdentity = null;
     #keyPairs;
     cloud;
     mail;
@@ -61,6 +62,16 @@ export class SecrecyClient extends BaseClient {
         this.group = new SecrecyGroupClient(this);
         this.identity = new SecrecyIdentityClient(this);
     }
+    get currentIdentity() {
+        return this.#currentGroupIdentity ?? this.#uaIdentity;
+    }
+    get currentIdentityPrivateKey() {
+        return this.getPrivateKey(this.currentIdentity.identityPubKey);
+    }
+    set currentGroup(groupId) {
+        this.#currentGroupIdentity =
+            this.#groupIdentities.find((g) => g.groupId === groupId) ?? null;
+    }
     get publicKey() {
         return this.#uaIdentity.identityPubKey;
     }

package/dist/lib/client/types/identity.js

@@ -11,6 +11,7 @@ export const groupSchema = z.object({
     groupId: z.string(),
     groupRole: z.enum(['ADMIN', 'MEMBER']),
     sharedByPubKey: z.string(),
+    sharedToPubKey: z.string(),
     groupOwnerPubKey: z.string(),
 });
 export const accessIdentitySchema = z.discriminatedUnion('kind', [

package/dist/lib/client/upload.js

@@ -11,11 +11,11 @@ import { promiseAllLimit } from '../utils/promise.js';
 import { encryptDataAndKey } from '../crypto/domain.js';
 import { derivePassword, generatePassword } from '../crypto/helpers.js';
 import { decryptCryptoBox, encryptSecretBox } from '../crypto/index.js';
-export async function uploadData({ storageType, data, password, forcePassword = false, encrypted = true, encryptProgress, uploadProgress, signal, meta, uaIdentity, keyPairs, apiClient, }) {
+export async function uploadData({ storageType, data, password, forcePassword = false, encrypted = true, encryptProgress, uploadProgress, signal, meta, currentIdentity, keyPairs, apiClient, }) {
     if (!encrypted && (password || forcePassword)) {
         throw new Error('Cannot share unencrypted data with a password!');
     }
-    if (encrypted && !password && !forcePassword && !uaIdentity) {
+    if (encrypted && !password && !forcePassword && !currentIdentity) {
         throw new Error('Cannot share encrypted data without a password!');
     }
     apiClient ??= getTrpcGuestClient();
@@ -37,7 +37,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
     if (storageType === 'lite' && dataBuffer.byteLength > kiloToBytes(1024)) {
         throw new Error('The data is too big for lite upload!');
     }
-    if (!uaIdentity && storageType === 'cold') {
+    if (!currentIdentity && storageType === 'cold') {
         throw new Error('Cold storage is only for logged users!');
     }
     const compressed = encrypted ? compress(dataBuffer) : dataBuffer;
@@ -45,7 +45,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
         ? await encryptDataAndKey({
             data: compressed,
             progress: encryptProgress,
-            uaIdentity,
+            currentIdentity,
             keyPairs,
             signal,
         })
@@ -74,7 +74,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 key = dataKey;
             }
             else {
-                if (!uaIdentity) {
+                if (!currentIdentity) {
                     throw new Error('Unable to encrypt data without keyPair!');
                 }
                 if (!data.key) {
@@ -104,6 +104,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 key: encryptedDataKey ? sodium.to_hex(encryptedDataKey) : undefined,
                 md5Encrypted,
                 md5: md5Data,
+                fromIdentityPubKey: currentIdentity?.identityPubKey,
                 ...filetype,
             }
             : {
@@ -111,6 +112,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 content: Buffer.from(encryptedData),
                 md5: md5Data,
                 size: BigInt(dataBuffer.byteLength),
+                fromIdentityPubKey: currentIdentity?.identityPubKey,
                 ...filetype,
             };
         const uploadData = await apiClient.cloud.uploadLiteData.mutate(uploadDataArgs, { signal });
@@ -146,12 +148,14 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 key: encryptedDataKey ? sodium.to_hex(encryptedDataKey) : undefined,
                 md5Encrypted,
                 md5: md5Data,
+                fromIdentityPubKey: currentIdentity?.identityPubKey,
                 ...filetype,
             }
             : {
                 type: 'unencrypted',
                 md5: md5Data,
                 size: BigInt(dataBuffer.byteLength),
+                fromIdentityPubKey: currentIdentity?.identityPubKey,
                 ...filetype,
             };
         const uploadDataCaller = storageType === 's3'

package/dist/lib/crypto/domain.js

@@ -10,10 +10,10 @@ import { concatenate } from '../utils/array.js';
  * If a string is provided as keypair, it should be considered as guest with password case.
  * If keypair is not provided, then we generate a key to be used as password for guest too.
  */
-export async function encryptDataAndKey({ data, uaIdentity, keyPairs, progress, signal, }) {
+export async function encryptDataAndKey({ data, currentIdentity, keyPairs, progress, signal, }) {
     const dataKey = secretStreamKeygen();
     const { data: encryptedData, md5: md5Data, md5Encrypted, } = await encrypt(dataKey, data, progress, signal);
-    if (!uaIdentity || !keyPairs) {
+    if (!currentIdentity || !keyPairs) {
         return {
             encryptedData,
             dataKey,
@@ -21,11 +21,11 @@ export async function encryptDataAndKey({ data, uaIdentity, keyPairs, progress,
             md5Encrypted,
         };
     }
-    const priv = keyPairs[uaIdentity.identityPubKey];
+    const priv = keyPairs[currentIdentity.identityPubKey];
     if (!priv) {
         throw new Error('No private key found for user app identity');
     }
-    const encDataKey = encryptCryptoBox(dataKey, uaIdentity.identityPubKey, priv);
+    const encDataKey = encryptCryptoBox(dataKey, currentIdentity.identityPubKey, priv);
     return {
         encryptedDataKey: encDataKey,
         encryptedData,

package/dist/types/client/SecrecyCloudClient.d.ts

@@ -52,6 +52,10 @@ export declare class SecrecyCloudClient {
         id?: string | null | undefined;
         deleted?: boolean | null | undefined;
     }): Promise<NodeFull>;
+    nodes({ ids, deleted, }: {
+        ids: string[];
+        deleted?: boolean | null | undefined;
+    }): Promise<NodeFull[]>;
     dataMetadata({ id }: {
         id: string;
     }): Promise<DataMetadata>;
@@ -124,7 +128,7 @@ export declare class SecrecyCloudClient {
         createdByOrgId: string | null;
         createdByAppId: string | null;
     }[]>;
-    checkAccesses(input: RouterInputs['cloud']['checkAccesses']): Promise<{
+    checkAccesses(input: Omit<RouterInputs['cloud']['checkAccesses'], 'fromIdentityPubKey'>): Promise<{
         isMatching: true;
     } | {
         isMatching: false;

package/dist/types/client/SecrecyMailClient.d.ts

@@ -33,7 +33,7 @@ export declare class SecrecyMailClient {
     unread({ mailId }: {
         mailId: string;
     }): Promise<boolean>;
-    receivedMails(input: RouterInputs['mail']['received']): Promise<ReceivedMail[]>;
+    receivedMails(input: Omit<RouterInputs['mail']['received'], 'fromIdentityPubKey'>): Promise<ReceivedMail[]>;
     sentMails(input: RouterInputs['mail']['sent']): Promise<SentMail[]>;
     draftMails(input: RouterInputs['mail']['draft']): Promise<DraftMail[]>;
     unreadReceivedMailsCount(): Promise<number>;

package/dist/types/client/index.d.ts

@@ -37,6 +37,9 @@ export declare class SecrecyClient extends BaseClient {
     group: SecrecyGroupClient;
     identity: SecrecyIdentityClient;
     constructor(opts: SecrecyClientOptions);
+    get currentIdentity(): Readonly<AccessIdentity>;
+    get currentIdentityPrivateKey(): string;
+    set currentGroup(groupId: string | null);
     get publicKey(): string;
     get apiClient(): Readonly<ApiClient>;
     get keyPairs(): Readonly<Record<string, string>>;

package/dist/types/client/types/identity.d.ts

@@ -14,6 +14,7 @@ export declare const groupSchema: z.ZodObject<{
         MEMBER: "MEMBER";
     }>;
     sharedByPubKey: z.ZodString;
+    sharedToPubKey: z.ZodString;
     groupOwnerPubKey: z.ZodString;
 }, z.core.$strip>;
 export declare const accessIdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -30,6 +31,7 @@ export declare const accessIdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         MEMBER: "MEMBER";
     }>;
     sharedByPubKey: z.ZodString;
+    sharedToPubKey: z.ZodString;
     groupOwnerPubKey: z.ZodString;
 }, z.core.$strip>], "kind">;
 export type AccessIdentity = z.infer<typeof accessIdentitySchema>;