@secrecy/lib 1.73.7 → 1.74.0-feat-groups-identity.1

package/dist/lib/base-client.js

@@ -111,10 +111,12 @@ export class BaseClient {
         const local = getStorage(false);
         const session = getStorage(true);
         local.jwt.clear();
-        local.userAppKeys.clear();
+        local.identities.clear();
+        local.keyPairs.clear();
         local.userAppSession.clear();
         session.jwt.clear();
-        session.userAppKeys.clear();
+        session.identities.clear();
+        session.keyPairs.clear();
         session.userAppSession.clear();
         usersCache.clear();
     };

package/dist/lib/client/SecrecyAppClient.js

@@ -4,15 +4,11 @@ import { publicKeysCache } from '../cache.js';
 export class SecrecyAppClient {
     jwt;
     jwtDecoded;
-    // #client: SecrecyClient
-    // #keys: KeyPair;
-    #apiClient;
-    constructor(uaJwt, _client, _keys, apiClient) {
+    #client;
+    constructor(uaJwt, client) {
         this.jwt = uaJwt;
         this.jwtDecoded = decode(uaJwt);
-        // this.#client = client
-        // this.#keys = keys;
-        this.#apiClient = apiClient;
+        this.#client = client;
     }
     get userId() {
         const sub = this.jwtDecoded.sub;
@@ -35,7 +31,7 @@ export class SecrecyAppClient {
         // if (this.jwtDecoded.exp && this.jwtDecoded.exp * 1000 < Date.now()) {
         //   return this.jwt;
         // }
-        const { jwt } = await this.#apiClient.auth.jwt.query({
+        const { jwt } = await this.#client.apiClient.auth.jwt.query({
             includeEmail: typeof this.jwtDecoded.email === 'string',
         });
         this.jwt = jwt;
@@ -53,19 +49,19 @@ export class SecrecyAppClient {
         return jwt;
     }
     async limits() {
-        return await this.#apiClient.application.limits.query({});
+        return await this.#client.apiClient.application.limits.query({});
     }
     async metrics() {
-        return await this.#apiClient.application.metrics.query({});
+        return await this.#client.apiClient.application.metrics.query({});
     }
     async quotas() {
-        return await this.#apiClient.application.quotas.query({});
+        return await this.#client.apiClient.application.quotas.query({});
     }
     async isApplicationUser(input) {
-        return await this.#apiClient.application.isApplicationUser.query(input);
+        return await this.#client.apiClient.application.isApplicationUser.query(input);
     }
     async updateNotifications(notifications) {
-        const updateAppNotifications = await this.#apiClient.application.updateNotification.mutate({
+        const updateAppNotifications = await this.#client.apiClient.application.updateNotification.mutate({
             cloud: notifications.cloud,
             disableAllUntil: notifications.disableAllUntil,
             enableAll: notifications.enableAll,
@@ -74,7 +70,7 @@ export class SecrecyAppClient {
         return updateAppNotifications;
     }
     async notifications() {
-        return await this.#apiClient.application.notification.query();
+        return await this.#client.apiClient.application.notification.query();
     }
     async userPublicKey(input, appId) {
         appId ??= this.appId;
@@ -92,7 +88,7 @@ export class SecrecyAppClient {
             ...new Set(userIds.filter((userId) => publicKeys[userId] === undefined)),
         ];
         if (missingKeys.length > 0) {
-            const userKeysMap = await this.#apiClient.application.userPublicKey.query({
+            const userKeysMap = await this.#client.apiClient.application.userPublicKey.query({
                 userIds: missingKeys,
                 appId,
             });
@@ -113,11 +109,11 @@ export class SecrecyAppClient {
         return Array.isArray(input) ? publicKeys : publicKeys[input];
     }
     async settings() {
-        const settings = await this.#apiClient.application.settings.query({});
+        const settings = await this.#client.apiClient.application.settings.query({});
         return settings;
     }
     async updateSettings(settings) {
-        const updateAppSettings = await this.#apiClient.application.updateSettings.mutate({
+        const updateAppSettings = await this.#client.apiClient.application.updateSettings.mutate({
             cloudNodeDaysForDelete: settings.cloudNodeDaysForDelete,
             historyDataDaysForDelete: settings.historyDataDaysForDelete,
             historyDataMaxCount: settings.historyDataMaxCount,

package/dist/lib/client/SecrecyCloudClient.js

@@ -17,36 +17,27 @@ import { chunkByTotalItems } from '../utils/object.js';
 import axios from 'axios';
 export class SecrecyCloudClient {
     #client;
-    #keys;
-    #apiClient;
-    constructor(client, keys, apiClient) {
+    constructor(client) {
         this.#client = client;
-        this.#keys = keys;
-        this.#apiClient = apiClient;
     }
     async addDataToHistory({ dataId, nodeId, }) {
-        const addDataToHistory = await this.#apiClient.cloud.addDataToHistory.mutate({ dataId, nodeId });
-        const node = await apiNodeFullToInternalFull(addDataToHistory, this.#keys);
+        const addDataToHistory = await this.#client.apiClient.cloud.addDataToHistory.mutate({
+            dataId,
+            nodeId,
+        });
+        const node = await apiNodeFullToInternalFull(addDataToHistory, this.#client.keyPairs);
         const data = node.history.find((d) => d.id === dataId);
         if (data !== undefined) {
-            // TODO sad to have to make this extra request
-            const me = await this.#client.me();
-            const users = node.users.filter(([u]) => u.id !== me.id);
-            const userIds = users.map(([user]) => user.id);
-            const userKeys = await this.#client.app.userPublicKey(userIds);
-            const shares = users.map(([user]) => {
-                const publicKey = userKeys[user.id];
-                if (!publicKey) {
-                    throw new Error('Unable to retrieve share by public key!');
-                }
+            const othersIdentities = Object.entries(node.identities).filter(([id]) => id !== this.#client.uaIdentity.identityPubKey);
+            const shares = othersIdentities.map(([publicKey]) => {
                 return {
-                    id: user.id,
+                    pubKey: publicKey,
                     key: data.key
-                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#keys.privateKey))
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#client.uaPrivateKey))
                         : null,
                 };
             });
-            await this.#apiClient.cloud.shareDataInHistory.mutate({
+            await this.#client.apiClient.cloud.shareDataInHistory.mutate({
                 dataId: data.id,
                 nodeId,
                 users: shares,
@@ -75,7 +66,7 @@ export class SecrecyCloudClient {
             ? await encrypt(dataKey, compressed, encryptProgress, signal)
             : { data: compressed, md5: await md5(compressed) };
         const encryptedDataKey = dataKey
-            ? encryptCryptoBox(dataKey, this.#keys.publicKey, this.#keys.privateKey)
+            ? encryptCryptoBox(dataKey, this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)
             : null;
         await uploadProgress?.({
             total: encryptedData.byteLength,
@@ -102,7 +93,7 @@ export class SecrecyCloudClient {
                     size: BigInt(dataBuffer.byteLength),
                     ...filetype,
                 };
-            const uploadData = await this.#apiClient.cloud.uploadLiteData.mutate(uploadDataArgs, { signal });
+            const uploadData = await this.#client.apiClient.cloud.uploadLiteData.mutate(uploadDataArgs, { signal });
             await uploadProgress?.({
                 total: encryptedData.byteLength,
                 current: encryptedData.byteLength,
@@ -138,14 +129,14 @@ export class SecrecyCloudClient {
                     ...filetype,
                 };
             const uploadDataCaller = storageType === 's3'
-                ? this.#apiClient.cloud.uploadData
-                : this.#apiClient.cloud.uploadColdData;
+                ? this.#client.apiClient.cloud.uploadData
+                : this.#client.apiClient.cloud.uploadColdData;
             const uploadData = await uploadDataCaller.mutate(uploadDataArgs, {
                 signal,
             });
             if (uploadData.parts.length === 0) {
                 if (uploadData.type === 'authed' &&
-                    uploadData.keyPair.pub !== this.#keys.publicKey) {
+                    uploadData.keyPair.pub !== this.#client.uaIdentity.identityPubKey) {
                     throw new Error('The public key does not match with cached key!');
                 }
                 await uploadProgress?.({
@@ -165,7 +156,7 @@ export class SecrecyCloudClient {
                 return localData;
             }
             const uploadDataPartEnd = async (md5, order) => {
-                return this.#apiClient.cloud.uploadDataPartEnd.mutate({ dataId: uploadData.id, md5, order }, { signal });
+                return this.#client.apiClient.cloud.uploadDataPartEnd.mutate({ dataId: uploadData.id, md5, order }, { signal });
             };
             const chunkParts = new Array();
             for (const [index, chunk] of enumerate(chunks(encryptedData, Number(uploadData.partSize)))) {
@@ -240,21 +231,21 @@ export class SecrecyCloudClient {
         return await this.saveInCloud({ dataId: uploadedData.id, name, nodeId });
     }
     async deletedNodes() {
-        const deletedNodes = await this.#apiClient.cloud.nodesDeleted.query({});
-        return await Promise.all(deletedNodes.map(async (node) => await apiNodeToExternal(node, this.#keys)));
+        const deletedNodes = await this.#client.apiClient.cloud.nodesDeleted.query({});
+        return await Promise.all(deletedNodes.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
     async sharedNodes() {
-        const nodesShared = await this.#apiClient.cloud.nodesShared.query();
-        return await Promise.all(nodesShared.map(async (node) => await apiNodeToExternal(node, this.#keys)));
+        const nodesShared = await this.#client.apiClient.cloud.nodesShared.query({});
+        return await Promise.all(nodesShared.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
     async nodesSharedWithMe(type = 'FOLDER') {
-        const nodesSharedWithMe = await this.#apiClient.cloud.nodesSharedWithMe.query({ type });
-        return await Promise.all(nodesSharedWithMe.map(async (node) => await apiNodeToExternal(node, this.#keys)));
+        const nodesSharedWithMe = await this.#client.apiClient.cloud.nodesSharedWithMe.query({ type });
+        return await Promise.all(nodesSharedWithMe.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
-    async deleteNodeSharing({ nodeId, userId, }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteNodeSharing.mutate({
+    async deleteNodeSharing({ nodeId, destPubKey, }) {
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeSharing.mutate({
             nodeId,
-            userId,
+            destPubKey,
         });
         return isDeleted;
     }
@@ -267,14 +258,14 @@ export class SecrecyCloudClient {
                 throw new Error(`Node (${nodeId}) does not exists`);
             }
         }
-        if (node.access?.nameKey === undefined) {
-            throw new Error(`Can't have access to node ${nodeId}`);
+        if (!node.accesses[0]) {
+            throw new Error(`No access found for node ${nodeId}`);
         }
         name =
-            typeof name === 'string' && node.access.nameKey !== null
-                ? await encryptName(name, node.access.nameKey)
+            typeof name === 'string' && node.accesses[0].nameKey !== null
+                ? await encryptName(name, node.accesses[0].nameKey)
                 : null;
-        const { isDuplicated } = await this.#apiClient.cloud.duplicateNode.mutate({
+        const { isDuplicated } = await this.#client.apiClient.cloud.duplicateNode.mutate({
             nodeId,
             folderId: folderId ?? null,
             name,
@@ -282,50 +273,54 @@ export class SecrecyCloudClient {
         return isDuplicated;
     }
     async deleteNodeCloudTrash({ ids }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteNodeCloudTrash.mutate({ ids });
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeCloudTrash.mutate({ ids });
         return isDeleted;
     }
     async createFolder({ name, parentFolderId, }) {
         const { encryptedNameKey, encryptedName } = await generateAndEncryptNameAndKey({
             name,
-            privateKey: this.#keys.privateKey,
-            publicKey: this.#keys.publicKey,
+            privateKey: this.#client.uaPrivateKey,
+            publicKey: this.#client.uaIdentity.identityPubKey,
         });
-        const createdFolder = await this.#apiClient.cloud.createFolder.mutate({
+        const createdFolder = await this.#client.apiClient.cloud.createFolder.mutate({
             name: encryptedName,
             parentId: parentFolderId ?? null,
             nameKey: encryptedNameKey,
         });
-        const folder = await apiNodeToExternalNodeFull(createdFolder, this.#keys);
-        const users = folder.parent?.users?.filter(([u]) => u.id !== folder.owner.id) ?? [];
-        if (users.length > 0) {
-            await this.shareNode(users.map(([user, permissions]) => ({
-                userId: user.id,
-                nodeId: folder.id,
-                rights: permissions.rights,
-                addAccess: permissions.addAccess,
-                delAccess: permissions.delAccess,
-                sharingAddAccess: permissions.sharingAddAccess,
-                sharingDelAccess: permissions.sharingDelAccess,
-            })));
+        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);
+            // TODO: ??
+            if (othersIdentities.length > 0) {
+                await this.shareNode(othersIdentities.map(([identityPubKey, permissions]) => ({
+                    pubKey: identityPubKey,
+                    nodeId: folder.id,
+                    rights: permissions.rights,
+                    addAccess: permissions.addAccess,
+                    delAccess: permissions.delAccess,
+                    sharingAddAccess: permissions.sharingAddAccess,
+                    sharingDelAccess: permissions.sharingDelAccess,
+                })));
+            }
         }
         return folder;
     }
     async node({ id, deleted, } = {}) {
-        const node = await this.#apiClient.cloud.nodeFullById.query({ id, deleted });
-        return await apiNodeToExternalNodeFull(node, this.#keys);
+        const node = await this.#client.apiClient.cloud.nodeFullById.query({
+            id,
+            deleted,
+        });
+        return await apiNodeToExternalNodeFull(node, this.#client.keyPairs);
     }
     async dataMetadata({ id }) {
-        const data = await this.#apiClient.cloud.dataById.query({ id });
-        return apiDataToExternal(data, this.#keys);
+        const data = await this.#client.apiClient.cloud.dataById.query({ id });
+        return apiDataToExternal(data, this.#client.keyPairs);
     }
-    async shareNode(input, progress) {
+    async shareNode(accesses, progress) {
         // TODO: Validate input
-        const nodesMap = await this.#apiClient.cloud.shareNode.mutate(input);
-        const neededUserKey = Object.entries(nodesMap)
-            .filter(([, nodes]) => nodes.some((node) => node.includeKeys))
-            .map(([userId]) => userId);
-        const publicKeysMap = await this.#client.app.userPublicKey(neededUserKey);
+        const nodesMap = await this.#client.apiClient.cloud.shareNode.mutate({
+            accesses,
+        });
         const maxNodesBatchSize = 1000;
         const totalNodesToShare = Object.values(nodesMap).reduce((size, ids) => size + ids.length, 0);
         progress?.({ total: totalNodesToShare, current: 0, percent: 0 });
@@ -342,9 +337,9 @@ export class SecrecyCloudClient {
                 return filtered.length > 0 ? [userId, filtered] : null;
             })
                 .filter((entry) => entry !== null));
-            const infos = await this.encryptNodesForUsers(nodesToEncrypt, publicKeysMap);
-            const nodesToUpdateRights = Object.fromEntries(Object.entries(nodesMap).map(([userId, nodes]) => [
-                userId,
+            const infos = await this.encryptNodesForIdentities(nodesToEncrypt);
+            const nodesToUpdateRights = Object.fromEntries(Object.entries(nodesMap).map(([pubKey, nodes]) => [
+                pubKey,
                 nodes
                     .filter((node) => !node.includeKeys)
                     .map((node) => {
@@ -360,13 +355,13 @@ export class SecrecyCloudClient {
                     };
                 }),
             ]));
-            const withKeys = Object.fromEntries(Object.entries(infos).map(([userId, nodes]) => {
+            const withKeys = Object.fromEntries(Object.entries(infos).map(([pubKey, nodes]) => {
                 return [
-                    userId,
+                    pubKey,
                     {
-                        userId,
+                        pubKey,
                         nodes: nodes.map((node) => {
-                            const map = nodesMap[userId];
+                            const map = nodesMap[pubKey];
                             if (!map) {
                                 throw new Error('Unable to retrieve mapped nodes!');
                             }
@@ -389,20 +384,22 @@ export class SecrecyCloudClient {
                 ];
             }));
             const finishInput = [];
-            for (const [userId, nodes] of Object.entries(withKeys)) {
+            for (const [pubKey, nodes] of Object.entries(withKeys)) {
                 if (nodes.nodes.length === 0) {
                     continue;
                 }
-                finishInput.push({ userId, nodes: nodes.nodes });
+                finishInput.push({ pubKey, nodes: nodes.nodes });
             }
-            for (const [userId, nodes] of Object.entries(nodesToUpdateRights)) {
+            for (const [pubKey, nodes] of Object.entries(nodesToUpdateRights)) {
                 if (nodes.length === 0) {
                     continue;
                 }
-                finishInput.push({ userId, nodes });
+                finishInput.push({ pubKey, nodes });
             }
             const subState = finishInput.length > 0
-                ? await this.#apiClient.cloud.shareNodeFinish.mutate(finishInput)
+                ? await this.#client.apiClient.cloud.shareNodeFinish.mutate({
+                    accesses: finishInput,
+                })
                 : { isFinished: true, details: {} };
             const currentProgress = Math.min((index + 1) * maxNodesBatchSize, totalNodesToShare);
             progress?.({
@@ -449,27 +446,31 @@ export class SecrecyCloudClient {
                 throw `Can't find Node ${nodeId}`;
             }
         }
-        if (node.access?.nameKey === undefined) {
-            throw new Error(`Can't have access to node ${nodeId}`);
+        if (node.accesses.find((a) => ['delete', 'write'].includes(a.rights)) ===
+            undefined) {
+            throw new Error(`No access to update node ${nodeId}`);
+        }
+        if (!node.accesses[0]) {
+            throw new Error(`No access found for node ${nodeId}`);
         }
         name =
-            typeof name === 'string' && node.access.nameKey !== null
-                ? await encryptName(name, node.access.nameKey)
+            typeof name === 'string' && node.accesses[0].nameKey !== null
+                ? await encryptName(name, node.accesses[0].nameKey)
                 : null;
-        const updateNode = await this.#apiClient.cloud.updateNode.mutate({
+        const updateNode = await this.#client.apiClient.cloud.updateNode.mutate({
             deletedAt: deletedAt ?? null,
             id: nodeId,
             isFavorite: isFavorite ?? null,
             name,
         });
-        return await apiNodeToExternalNodeFull(updateNode, this.#keys);
+        return await apiNodeToExternalNodeFull(updateNode, this.#client.keyPairs);
     }
     async dataContent({ dataId, onDownloadProgress, progressDecrypt, signal, }) {
         const cached = dataContentCache.get(dataId);
         if (cached !== undefined) {
             return cached;
         }
-        const dataContent = await this.#apiClient.cloud.dataContentById.query({
+        const dataContent = await this.#client.apiClient.cloud.dataContentById.query({
             id: dataId,
         });
         const totalBytes = Number(dataContent.sizeEncrypted ?? dataContent.size);
@@ -490,7 +491,7 @@ export class SecrecyCloudClient {
         if (cachedData.length === dataIds.length) {
             return cachedData;
         }
-        const missingContents = await this.#apiClient.cloud.dataContentByIds.query({
+        const missingContents = await this.#client.apiClient.cloud.dataContentByIds.query({
             ids: dataIds.filter((dataId) => !cachedData.some((datum) => datum.id === dataId)),
         });
         const allDataContents = [
@@ -521,33 +522,33 @@ export class SecrecyCloudClient {
         }));
     }
     async deleteNodes({ nodeIds, }) {
-        return this.#apiClient.cloud.deleteNodes.mutate({ ids: nodeIds });
+        return this.#client.apiClient.cloud.deleteNodes.mutate({ ids: nodeIds });
     }
     async deleteData({ dataId, nodeId, }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteData.mutate({
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteData.mutate({
             dataId,
             nodeId,
         });
         return isDeleted;
     }
     async deleteNode({ nodeId }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteNode.mutate({
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteNode.mutate({
             id: nodeId,
         });
         return isDeleted;
     }
     async emptyTrash() {
-        const { isCleaned } = await this.#apiClient.cloud.emptyNodeCloudTrash.mutate({});
+        const { isCleaned } = await this.#client.apiClient.cloud.emptyNodeCloudTrash.mutate({});
         return isCleaned;
     }
     async recoverNode(id) {
-        const { isRecovered } = await this.#apiClient.cloud.recoverNode.mutate({
+        const { isRecovered } = await this.#client.apiClient.cloud.recoverNode.mutate({
             id,
         });
         return isRecovered;
     }
     async moveNodes({ nodeIds, parentNodeId, }) {
-        const { isMoved } = await this.#apiClient.cloud.moveNodes.mutate({
+        const { isMoved } = await this.#client.apiClient.cloud.moveNodes.mutate({
             ids: nodeIds,
             parentId: parentNodeId ?? null,
         });
@@ -592,7 +593,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.#keys.privateKey)
+                    ? decryptCryptoBox(sodium.from_hex(attachment.key), senderPubKey, this.#client.uaPrivateKey)
                     : null;
                 key = dataKey !== null ? sodium.to_hex(dataKey) : null;
             }
@@ -604,28 +605,27 @@ export class SecrecyCloudClient {
             key = data.key;
         }
         key = key
-            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#keys.publicKey, this.#keys.privateKey))
+            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey))
             : null;
         const { encryptedNameKey, encryptedName } = await generateAndEncryptNameAndKey({
             name,
-            privateKey: this.#keys.privateKey,
-            publicKey: this.#keys.publicKey,
+            privateKey: this.#client.uaPrivateKey,
+            publicKey: this.#client.uaIdentity.identityPubKey,
         });
-        const saveInCloud = await this.#apiClient.cloud.saveInCloud.mutate({
+        const saveInCloud = await this.#client.apiClient.cloud.saveInCloud.mutate({
             dataId,
             key,
             nodeId: nodeId ?? null,
             fileName: encryptedName,
             nameKey: encryptedNameKey,
         });
-        const node = await apiNodeToExternalNodeFull(saveInCloud, this.#keys);
-        const me = node.parent?.users.find(([u]) => u.id === node.owner.id);
-        // TODO: ??
-        if (me !== undefined && ['delete', 'write'].includes(me[1].rights)) {
-            const others = node.parent?.users.filter(([u]) => u.id !== node.owner.id) ?? [];
-            if (others.length > 0) {
-                await this.shareNode(others.map(([user, permissions]) => ({
-                    userId: user.id,
+        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);
+            // TODO: ??
+            if (othersIdentities.length > 0) {
+                await this.shareNode(othersIdentities.map(([identityPubKey, permissions]) => ({
+                    pubKey: identityPubKey,
                     nodeId: node.id,
                     ...permissions,
                 })));
@@ -633,20 +633,13 @@ export class SecrecyCloudClient {
         }
         return node;
     }
-    encryptNodesForUsers = async (userNodes, // { [userId]: nodeIds[] }
-    userPublicKeys) => {
-        const userIds = Object.keys(userNodes).map((userId) => userId);
-        const nodeIds = Object.values(userNodes).flatMap((nodeIds) => nodeIds);
+    encryptNodesForIdentities = async (identityNodes) => {
+        const pubKeys = Object.keys(identityNodes).map((identityPubKey) => identityPubKey);
+        const nodeIds = Object.values(identityNodes).flatMap((nodeIds) => nodeIds);
         if (nodeIds.length === 0) {
             return {};
         }
         const nodes = [];
-        // Pre check to ensure we get all public keys for users!
-        for (const userId of userIds) {
-            if (userPublicKeys[userId] === undefined) {
-                throw new Error(`Unable to retrieve some user public keys!`);
-            }
-        }
         // Retrieve and format nodes.
         for (const nodeId of nodeIds) {
             let node = nodesEncryptionCache.get(nodeId) ?? nodesCache.get(nodeId);
@@ -671,7 +664,7 @@ export class SecrecyCloudClient {
         // Retrieve all missing nodes from cache to api.
         const missingNodeIds = nodeIds.filter((nodeId) => !nodes.some((node) => node.id === nodeId));
         const fetchedNodes = missingNodeIds.length > 0
-            ? await this.#apiClient.cloud.nodesForEncryption.query({
+            ? await this.#client.apiClient.cloud.nodesForEncryption.query({
                 ids: missingNodeIds,
             })
             : [];
@@ -680,13 +673,13 @@ export class SecrecyCloudClient {
             throw new Error(`Unable to fetch some node infos (${diff.join(', ')})`);
         }
         const finalNodes = await Promise.all(fetchedNodes.map((node) => {
-            return apiNodeForEncryptionToInternal(node, this.#keys);
+            return apiNodeForEncryptionToInternal(node, this.#client.keyPairs);
         }));
         nodes.push(...finalNodes);
         const nodesMappedUsers = {};
-        for (const userId in userNodes) {
-            nodesMappedUsers[userId] ??= [];
-            for (const nodeId of userNodes[userId]) {
+        for (const pubKey in identityNodes) {
+            nodesMappedUsers[pubKey] ??= [];
+            for (const nodeId of identityNodes[pubKey]) {
                 const node = nodes.find((node) => node.id === nodeId);
                 if (!node) {
                     throw new Error('Unable to retrieve node from ram');
@@ -696,17 +689,16 @@ export class SecrecyCloudClient {
                     throw new Error(`Can't share a node without data (${node.id})!`);
                 }
                 const nameKey = node.access?.nameKey;
-                const publicKey = userPublicKeys[userId];
-                nodesMappedUsers[userId].push({
+                nodesMappedUsers[pubKey].push({
                     id: node.id,
                     nameKey: nameKey !== null
-                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), publicKey, this.#keys.privateKey))
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), pubKey, this.#client.uaPrivateKey))
                         : null,
                     data: 'history' in node
                         ? node.history.map((f) => ({
                             id: f.id,
                             key: f.key
-                                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), publicKey, this.#keys.privateKey))
+                                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), pubKey, this.#client.uaPrivateKey))
                                 : null,
                         }))
                         : [],
@@ -717,15 +709,15 @@ export class SecrecyCloudClient {
     };
     async reportData({ id, reasons, }) {
         const [rawData, secrecy] = await Promise.all([
-            this.#apiClient.cloud.dataById.query({ id }),
-            this.#apiClient.misc.publicKey.query(),
+            this.#client.apiClient.cloud.dataById.query({ id }),
+            this.#client.apiClient.misc.publicKey.query(),
         ]);
-        const data = apiDataToInternal(rawData, this.#keys);
-        return this.#apiClient.cloud.reportData.mutate({
+        const data = apiDataToInternal(rawData, this.#client.keyPairs);
+        return this.#client.apiClient.cloud.reportData.mutate({
             id: id,
             reasons: reasons,
             encryptedDataKey: data.key
-                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), secrecy.publicKey, this.#keys.privateKey))
+                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), secrecy.publicKey, this.#client.uaPrivateKey))
                 : null,
         });
     }
@@ -739,28 +731,28 @@ export class SecrecyCloudClient {
                 throw new Error("It's not possible to transfer a cold stored data to a lite storage!");
             }
         }
-        return this.#apiClient.cloud.moveToStorageType.mutate(input);
+        return this.#client.apiClient.cloud.moveToStorageType.mutate(input);
     }
     getPublicDataLink(input) {
-        return this.#apiClient.cloud.dataLink.query(input);
+        return this.#client.apiClient.cloud.dataLink.query(input);
     }
     getPublicDataLinks(input) {
-        return this.#apiClient.cloud.dataLinks.query(input);
+        return this.#client.apiClient.cloud.dataLinks.query(input);
     }
     checkAccesses(input) {
-        return this.#apiClient.cloud.checkAccesses.query(input);
+        return this.#client.apiClient.cloud.checkAccesses.query(input);
     }
     createPublicDataLink(input) {
         if (input.expireAt && input.expireAt <= new Date()) {
             throw new Error('Unable to create public link using a past expireAt date!');
         }
-        return this.#apiClient.cloud.createDataLink.mutate(input);
+        return this.#client.apiClient.cloud.createDataLink.mutate(input);
     }
     updatePublicDataLink(input) {
-        return this.#apiClient.cloud.updateDataLink.mutate(input);
+        return this.#client.apiClient.cloud.updateDataLink.mutate(input);
     }
     deletePublicDataLink(input) {
-        return this.#apiClient.cloud.deleteDataLink.mutate(input);
+        return this.#client.apiClient.cloud.deleteDataLink.mutate(input);
     }
     async _handleDataContent({ dataContent, totalBytes, progressParts, onDownloadProgress, progressDecrypt, signal, }) {
         const onProgress = (key, progressEvent) => {
@@ -827,7 +819,7 @@ export class SecrecyCloudClient {
                 ? dataContent.senderPublicKey
                 : dataContent.type === 'cloud' || dataContent.type === 'lite'
                     ? dataContent.publicKey
-                    : this.#keys.publicKey, this.#keys.privateKey)
+                    : this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)
             : null;
         const src = key
             ? await decrypt(key, encryptedContent, progressDecrypt, signal)