@secrecy/lib 1.7.0 → 1.8.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Anonymize
+Copyright (c) 2024 Anonymize
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/lib/base-client.js

@@ -0,0 +1,91 @@
+import { getLink } from '@secrecy/lib-utils';
+import { usersCache } from './cache.js';
+import { getStorage } from './client/storage.js';
+import { createTRPCClient, } from './client.js';
+async function getPublicUser(client, id) {
+    let user = usersCache.get(id);
+    if (user !== undefined) {
+        return user;
+    }
+    user = await client.user.byId.query({
+        id,
+    });
+    usersCache.set(user.id, user);
+    return user;
+}
+export class BaseClient {
+    static getBaseClient = (session, onAccessDenied) => createTRPCClient(session, onAccessDenied);
+    client;
+    sessionId;
+    constructor(session) {
+        this.sessionId = session;
+        this.client = BaseClient.getBaseClient(session, () => {
+            this.#clean();
+            location.reload();
+        });
+    }
+    async logout(sessionId) {
+        if (sessionId === null || sessionId === undefined) {
+            this.#clean();
+        }
+        await this.client.auth.logout.mutate({
+            sessionId: sessionId ?? null,
+        });
+    }
+    async me() {
+        return await this.client.user.self.query({});
+    }
+    static async getUser(userId, sessionId) {
+        const user = await getPublicUser(this.getBaseClient(sessionId), userId);
+        return user;
+    }
+    async getUser(userId) {
+        const user = await getPublicUser(this.client, userId);
+        return user;
+    }
+    async searchUsers(search) {
+        const users = await this.client.user.searchMany.query({
+            search,
+        });
+        return users;
+    }
+    async updateProfile(data) {
+        const updateProfile = await this.client.user.updateProfile.mutate(data);
+        return updateProfile; // TODO
+    }
+    static async isCryptoTransactionDone({ idOrHash, network = 'mainnet', }) {
+        const { isDone } = await this.getBaseClient().crypto.isTransactionDone.query({
+            idOrHash,
+            network,
+        });
+        return isDone;
+    }
+    async reportUser(data) {
+        return await this.client.report.create.mutate(data);
+    }
+    async getSponsorshipLink({ backUrl, }) {
+        const me = await this.me();
+        return getLink({
+            app: 'auth',
+            path: `/sign-up?gf=${btoa(me.account.emails[0])}&au=${btoa(backUrl)}`,
+        });
+    }
+    static getPaymentRequest = async ({ paymentRequestId, secrecyIdSeller, }) => {
+        const getPaymentRequestToPay = await BaseClient.getBaseClient().stripe.paymentRequestToPay.query({
+            paymentRequestId,
+            sellerId: secrecyIdSeller,
+        });
+        return getPaymentRequestToPay;
+    };
+    #clean = () => {
+        const local = getStorage(false);
+        const session = getStorage(true);
+        local.jwt.clear();
+        local.userAppKeys.clear();
+        local.userAppSession.clear();
+        session.jwt.clear();
+        session.userAppKeys.clear();
+        session.userAppSession.clear();
+        usersCache.clear();
+    };
+}

package/dist/lib/cache.js

@@ -0,0 +1,4 @@
+export const filesCache = new Map();
+export const nodesCache = new Map();
+export const usersCache = new Map();
+export const publicKeysCache = new Map();

package/dist/lib/client/SecrecryCareClient.js

@@ -0,0 +1,19 @@
+export class SecrecyCareClient {
+    #client;
+    #keys;
+    #apiClient;
+    constructor(client, keys, apiClient) {
+        this.#client = client;
+        this.#keys = keys;
+        this.#apiClient = apiClient;
+    }
+    async getProfessional(input) {
+        return await this.#apiClient.care.professional.get.query(input);
+    }
+    async listProfessionals(input) {
+        return await this.#apiClient.care.professional.list.query(input);
+    }
+    async registerProfessional(input) {
+        return await this.#apiClient.care.professional.register.mutate(input);
+    }
+}

package/dist/lib/client/SecrecyAppClient.js

@@ -0,0 +1,87 @@
+import { decode } from 'jsonwebtoken';
+import { getStorage } from './storage.js';
+import { publicKeysCache } from '../cache.js';
+export class SecrecyAppClient {
+    jwt;
+    jwtDecoded;
+    // #client: SecrecyClient
+    // #keys: KeyPair;
+    #apiClient;
+    constructor(uaJwt, _client, _keys, apiClient) {
+        this.jwt = uaJwt;
+        this.jwtDecoded = decode(uaJwt);
+        // this.#client = client
+        // this.#keys = keys;
+        this.#apiClient = apiClient;
+    }
+    get userId() {
+        return this.jwtDecoded.sub ?? '';
+    }
+    async getJwt() {
+        // TODO useful?
+        // if (this.jwtDecoded.exp && this.jwtDecoded.exp * 1000 < Date.now()) {
+        //   return this.jwt;
+        // }
+        const { jwt } = await this.#apiClient.auth.jwt.query({
+            includeEmail: typeof this.jwtDecoded.email === 'string',
+        });
+        this.jwt = jwt;
+        this.jwtDecoded = decode(jwt);
+        const sessionStorage = getStorage(true);
+        const localStorage = getStorage(false);
+        const sessionJwt = sessionStorage.jwt.load();
+        const localJwt = localStorage.jwt.load();
+        if (sessionJwt !== null) {
+            sessionStorage.jwt.save(jwt);
+        }
+        if (localJwt !== null) {
+            localStorage.jwt.save(jwt);
+        }
+        return jwt;
+    }
+    async limits() {
+        return await this.#apiClient.application.limits.query({});
+    }
+    async metrics() {
+        return await this.#apiClient.application.metrics.query({});
+    }
+    async quotas() {
+        return await this.#apiClient.application.quotas.query({});
+    }
+    async updateNotifications(notifications) {
+        const updateAppNotifications = await this.#apiClient.application.updateNotification.mutate({
+            cloud: notifications.cloud,
+            disableAllUntil: notifications.disableAllUntil,
+            enableAll: notifications.enableAll,
+            mail: notifications.mail,
+        });
+        return updateAppNotifications;
+    }
+    async notifications() {
+        return await this.#apiClient.application.notification.query();
+    }
+    async userPublicKey(userId) {
+        const key = `userPublicKey:${userId}-${this.jwtDecoded.aud?.toString()}`;
+        const cachedPublicKey = publicKeysCache.get(key);
+        if (cachedPublicKey !== undefined) {
+            return cachedPublicKey;
+        }
+        const { publicKey } = await this.#apiClient.application.userPublicKey.query({
+            userId,
+        });
+        publicKeysCache.set(key, publicKey);
+        return publicKey;
+    }
+    async settings() {
+        const settings = await this.#apiClient.application.settings.query({});
+        return settings;
+    }
+    async updateSettings(settings) {
+        const updateAppSettings = await this.#apiClient.application.updateSettings.mutate({
+            cloudNodeDaysForDelete: settings.cloudNodeDaysForDelete,
+            historyFileDaysForDelete: settings.historyFileDaysForDelete,
+            historyMaxFileCount: settings.historyMaxFileCount,
+        });
+        return updateAppSettings;
+    }
+}

package/dist/lib/client/SecrecyCloudClient.js

@@ -0,0 +1,475 @@
+import axios from 'axios';
+import ky from 'ky';
+import { encryptName } from '../index.js';
+import { nodesCache, filesCache } from '../cache.js';
+import { secretstreamKeygen } from '../crypto/file.js';
+import { decryptCryptoBox, encryptCryptoBox } from '../crypto/index.js';
+import { compress, decompress } from '../minify/index.js';
+import { sodium } from '../sodium.js';
+import { enumerate, chunks, concatenate } from '../utils/array.js';
+import { md5 } from '../worker/md5.js';
+import { decrypt, encrypt } from '../worker/sodium.js';
+import { apiFileToExternal } from './convert/file.js';
+import { apiNodeFullToInternalFull, apiNodeToExternal, apiNodeToExternalNodeFull, internalNodeFullToNodeFull, } from './convert/node.js';
+import { promiseAllLimit } from '../utils/promise.js';
+// import { md5 } from "../worker/index.js";
+// import { firstValueFrom, of } from "rxjs";
+export class SecrecyCloudClient {
+    #client;
+    #keys;
+    #apiClient;
+    constructor(client, keys, apiClient) {
+        this.#client = client;
+        this.#keys = keys;
+        this.#apiClient = apiClient;
+    }
+    async addFileToHistory({ fileId, nodeId, }) {
+        const addFileToHistory = await this.#apiClient.cloud.addFileToHistory.mutate({
+            fileId,
+            nodeId,
+        });
+        const node = await apiNodeFullToInternalFull(addFileToHistory, this.#keys);
+        const file = node.history.find((f) => f.id === fileId);
+        if (file !== undefined) {
+            const users = node.users.filter(([u]) => u.id !== this.#client.app.userId);
+            await this.#apiClient.cloud.shareFileInHistory.mutate({
+                fileId: file.id,
+                nodeId,
+                users: users.map(([u]) => ({
+                    id: u.id,
+                    key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(file.key), this.#keys.publicKey, this.#keys.privateKey)),
+                })),
+            });
+        }
+        return internalNodeFullToNodeFull(node);
+    }
+    async uploadFile({ file, encryptProgress, uploadProgress, signal, }) {
+        const fileKey = secretstreamKeygen();
+        const fileBuffer = file instanceof File ? new Uint8Array(await file.arrayBuffer()) : file;
+        const compressed = compress(fileBuffer);
+        const { data: encryptedFile, md5: md5File, md5Encrypted, } = await encrypt(fileKey, compressed, encryptProgress, signal);
+        const encryptedFileKey = encryptCryptoBox(fileKey, this.#keys.publicKey, this.#keys.privateKey);
+        const uploadFile = await this.#apiClient.cloud.uploadFile.mutate({
+            fileSize: BigInt(encryptedFile.byteLength),
+            fileSizeBefore: BigInt(fileBuffer.byteLength),
+            fileKey: sodium.to_hex(encryptedFileKey),
+            md5Encrypted,
+            md5: md5File,
+        });
+        await uploadProgress?.({
+            total: encryptedFile.byteLength,
+            current: 0,
+            percent: 0,
+        });
+        if (uploadFile.parts.length === 0) {
+            await uploadProgress?.({
+                total: encryptedFile.byteLength,
+                current: encryptedFile.byteLength,
+                percent: 1,
+            });
+            return uploadFile.fileId;
+        }
+        const uploadPartEnded = async (md5, order) => {
+            const { isUploadPartEnded } = await this.#apiClient.cloud.uploadFilePartEnd.mutate({
+                fileId: uploadFile.fileId,
+                md5,
+                order,
+            });
+            return isUploadPartEnded;
+        };
+        const uploadEnded = async () => {
+            const { isUploadEnded } = await this.#apiClient.cloud.uploadFileEnd.mutate({
+                fileId: uploadFile.fileId,
+            });
+            return isUploadEnded;
+        };
+        const chunkParts = new Array();
+        for (const [index, chunk] of enumerate(chunks(encryptedFile, Number(uploadFile.filePartSize)))) {
+            chunkParts.push({
+                order: index + 1,
+                data: chunk,
+                md5: await md5(chunk),
+            });
+        }
+        const progressParts = {};
+        const onProgress = (part, progressEvent) => {
+            progressParts[part] = progressEvent;
+            const current = Object.values(progressParts).reduce((prv, cur) => prv + cur.loaded, 0);
+            void uploadProgress?.({
+                percent: current / encryptedFile.byteLength,
+                total: encryptedFile.byteLength,
+                current,
+            });
+        };
+        const byPart = async (part) => {
+            const formData = new FormData();
+            const chunk = chunkParts.find((p) => p.order === part.order);
+            if (chunk === undefined) {
+                return;
+            }
+            for (const [key, value] of Object.entries(part.fields)) {
+                formData.append(key, value);
+            }
+            formData.append('file', new Blob([chunk.data]), `${uploadFile.fileId}-${chunk.order}`);
+            await axios.post(part.url, formData, {
+                onUploadProgress: (progressEvent) => {
+                    onProgress(part.order, progressEvent);
+                },
+                signal,
+            });
+            await uploadPartEnded(chunk.md5, chunk.order);
+            // if ((e as any).response.status === 0) {
+            //   // TODO https://github.com/sindresorhus/ky/issues/305
+            // } else {
+            //   throw e;
+            // }
+        };
+        await promiseAllLimit(3, uploadFile.parts.map((p) => async () => {
+            await byPart(p);
+        }));
+        await uploadEnded();
+        return uploadFile.fileId;
+    }
+    async uploadFileInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal, }) {
+        const fileId = await this.uploadFile({
+            file,
+            encryptProgress,
+            uploadProgress,
+            signal,
+        });
+        return await this.saveInCloud({
+            fileId,
+            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)));
+    }
+    async sharedNodes() {
+        const nodesShared = await this.#apiClient.cloud.nodesShared.query();
+        return await Promise.all(nodesShared.map(async (node) => await apiNodeToExternal(node, this.#keys)));
+    }
+    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)));
+    }
+    async deleteNodeSharing({ nodeId, userId, }) {
+        const { isDeleted } = await this.#apiClient.cloud.deleteNodeSharing.mutate({
+            nodeId,
+            userId,
+        });
+        return isDeleted;
+    }
+    async duplicateNode({ nodeId, folderId, customName, }) {
+        let node = nodesCache.get(nodeId);
+        if (node === undefined) {
+            await this.node({ id: nodeId });
+            node = nodesCache.get(nodeId);
+            if (node === undefined) {
+                throw new Error(`Node (${nodeId}) does not exists`);
+            }
+        }
+        if (node.access?.nameKey === undefined) {
+            throw new Error(`Can't have access to node ${nodeId}`);
+        }
+        customName =
+            typeof customName === 'string' && node.access.nameKey !== null
+                ? await encryptName(customName, node.access.nameKey)
+                : null;
+        const { isDuplicated } = await this.#apiClient.cloud.duplicateNode.mutate({
+            nodeId,
+            folderId: folderId ?? null,
+            name: customName,
+        });
+        return isDuplicated;
+    }
+    async deleteNodeCloudTrash({ ids }) {
+        const { isDeleted } = await this.#apiClient.cloud.deleteNodeCloudTrash.mutate({
+            ids,
+        });
+        return isDeleted;
+    }
+    async createFolder({ name, parentFolderId, }) {
+        const key = secretstreamKeygen();
+        const encryptedName = await encryptName(name, sodium.to_hex(key));
+        const encryptedKey = encryptCryptoBox(key, this.#keys.publicKey, this.#keys.privateKey);
+        const createFolder = await this.#apiClient.cloud.createFolder.mutate({
+            name: encryptedName,
+            parentId: parentFolderId ?? null,
+            nameKey: sodium.to_hex(encryptedKey),
+        });
+        const folder = await apiNodeToExternalNodeFull(createFolder, this.#keys);
+        const users = folder.parent?.users?.filter(([u]) => u.id !== this.#client.app.userId) ??
+            [];
+        if (users.length > 0) {
+            await Promise.all(users.map(async ([u, rights]) => await this.shareNode({
+                nodeId: folder.id,
+                rights,
+                userId: u.id,
+            })));
+        }
+        return folder;
+    }
+    async node({ id, deleted, } = {}) {
+        const node = await this.#apiClient.cloud.nodeFullById.query({
+            id,
+            deleted,
+        });
+        return await apiNodeToExternalNodeFull(node, this.#keys);
+    }
+    async fileMetadata({ id }) {
+        const file = await this.#apiClient.cloud.fileById.query({
+            id,
+        });
+        return apiFileToExternal(file, this.#keys);
+    }
+    async shareNode({ nodeId, userId, rights, }) {
+        const publicKey = await this.#client.app.userPublicKey(userId);
+        const { ids } = await this.#apiClient.cloud.shareNode.mutate({
+            nodeId,
+            userId,
+        });
+        const shareNodes = [];
+        for (const id of ids) {
+            const nameKey = await this.perNode(id, publicKey);
+            if (nameKey !== null) {
+                shareNodes.push(nameKey);
+            }
+        }
+        const { isFinished } = await this.#apiClient.cloud.shareNodeFinish.mutate({
+            rights,
+            userId,
+            nodes: shareNodes,
+        });
+        return isFinished;
+    }
+    async updateNode({ nodeId, name, isFavorite, deletedAt, }) {
+        let node = nodesCache.get(nodeId);
+        if (node === undefined) {
+            await this.node({ id: nodeId });
+            node = nodesCache.get(nodeId);
+            if (node === undefined) {
+                throw `Can't find Node ${nodeId}`;
+            }
+        }
+        if (node.access?.nameKey === undefined) {
+            throw new Error(`Can't have access to node ${nodeId}`);
+        }
+        name =
+            typeof name === 'string' && node.access.nameKey !== null
+                ? await encryptName(name, node.access.nameKey)
+                : null;
+        const updateNode = await this.#apiClient.cloud.updateNode.mutate({
+            deletedAt: deletedAt ?? null,
+            id: nodeId,
+            isFavorite: isFavorite ?? null,
+            name,
+        });
+        return await apiNodeToExternalNodeFull(updateNode, this.#keys);
+    }
+    async fileContent({ fileId, onDownloadProgress, progressDecrypt, signal, }) {
+        const fileContent = await this.#apiClient.cloud.fileContentById.query({
+            id: fileId,
+        });
+        const progressParts = {};
+        const onProgress = (part, progressEvent) => {
+            progressParts[part] = progressEvent;
+            const transferredBytes = Object.values(progressParts).reduce((prv, cur) => prv + cur.transferredBytes, 0);
+            const totalBytes = Number(fileContent.totalSize);
+            onDownloadProgress?.({
+                percent: transferredBytes / totalBytes,
+                totalBytes,
+                transferredBytes,
+            });
+        };
+        const encryptedContentFromParts = async (fileParts) => {
+            const parts = new Array();
+            const byPart = async (part) => {
+                const buf = new Uint8Array(await ky
+                    .get(part.contentUrl, {
+                    timeout: false,
+                    onDownloadProgress: (pr) => {
+                        onProgress(part.order, pr);
+                    },
+                    signal,
+                })
+                    .arrayBuffer());
+                const md5Part = await md5(buf);
+                if (md5Part !== part.md5) {
+                    throw new Error(`Invalid md5 for part ${part.order} of file ${fileId}`);
+                }
+                parts.push({
+                    data: buf,
+                    order: part.order,
+                });
+            };
+            await promiseAllLimit(3, fileParts.map((p) => async () => {
+                await byPart(p);
+            }));
+            return concatenate(...parts.sort((a, b) => a.order - b.order).map((p) => p.data));
+        };
+        const finalize = async (encryptedContent) => {
+            // const md5Encrypted = await firstValueFrom(md5(of(encryptedContent)));
+            const md5Encrypted = await md5(encryptedContent);
+            if (md5Encrypted !== fileContent.md5Encrypted) {
+                throw new Error(`Encrypted content does not match`);
+            }
+            const key = decryptCryptoBox(sodium.from_hex(fileContent.key), fileContent.type === 'received_mail'
+                ? fileContent.senderPublicKey
+                : fileContent.type === 'cloud'
+                    ? fileContent.publicKey
+                    : this.#keys.publicKey, this.#keys.privateKey);
+            const src = await decrypt(key, encryptedContent, progressDecrypt, signal);
+            // const md5Content = await firstValueFrom(md5(of(src)));
+            const md5Content = await md5(src);
+            if (md5Content !== fileContent.md5) {
+                throw new Error(`Content does not match`);
+            }
+            return decompress(src);
+        };
+        const encryptedContent = fileContent.type === 'lite'
+            ? fileContent.content
+            : fileContent.type === 'cloud'
+                ? await encryptedContentFromParts(fileContent.parts)
+                : // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+                    fileContent.maybeContent !== null
+                        ? fileContent.maybeContent
+                        : fileContent.maybeParts !== null
+                            ? await encryptedContentFromParts(fileContent.maybeParts)
+                            : null;
+        if (encryptedContent === null) {
+            throw `Can't find content for file ${fileId}`;
+        }
+        return await finalize(encryptedContent);
+    }
+    async deleteFile({ fileId, nodeId, }) {
+        const { isDeleted } = await this.#apiClient.cloud.deleteFile.mutate({
+            fileId,
+            nodeId,
+        });
+        return isDeleted;
+    }
+    async deleteNode({ nodeId }) {
+        const { isDeleted } = await this.#apiClient.cloud.deleteNode.mutate({
+            id: nodeId,
+        });
+        return isDeleted;
+    }
+    async emptyTrash() {
+        const { isCleaned } = await this.#apiClient.cloud.emptyNodeCloudTrash.mutate({});
+        return isCleaned;
+    }
+    async recoverNode(id) {
+        const { isRecovered } = await this.#apiClient.cloud.recoverNode.mutate({
+            id,
+        });
+        return isRecovered;
+    }
+    async moveNodes({ nodeIds, parentNodeId, }) {
+        const { isMoved } = await this.#apiClient.cloud.moveNodes.mutate({
+            ids: nodeIds,
+            parentId: parentNodeId ?? null,
+        });
+        return isMoved;
+    }
+    async saveInCloud({ fileId, name, nodeId, }) {
+        if (nodeId !== undefined && !nodesCache.has(nodeId)) {
+            await this.node({ id: nodeId });
+            if (!nodesCache.has(nodeId)) {
+                const err = {
+                    name: 'ClientError',
+                    code: 'NOT_FOUND',
+                    message: `The node ${nodeId} does not exists`,
+                };
+                throw err;
+            }
+        }
+        let key = '';
+        const file = filesCache.get(fileId);
+        if (file === undefined) {
+            await this.fileMetadata({ id: fileId });
+            const file = filesCache.get(fileId);
+            if (file === undefined) {
+                const receivedMails = await this.#client.mail.receivedMails();
+                const mail = receivedMails.find((m) => m.files.some((f) => f.id === fileId));
+                if (mail === undefined) {
+                    const err = {
+                        name: 'ClientError',
+                        code: 'NOT_FOUND',
+                        message: `Can't find mail with the file ${fileId}`,
+                    };
+                    throw err;
+                }
+                const fileMail = mail.files.find((f) => f.id === fileId);
+                if (fileMail === undefined) {
+                    const err = {
+                        name: 'ClientError',
+                        code: 'NOT_FOUND',
+                        message: `Can't find mail with the file ${fileId}`,
+                    };
+                    throw err;
+                }
+                const senderPubKey = await this.#client.app.userPublicKey(mail.sender.id);
+                const fileKey = decryptCryptoBox(sodium.from_hex(fileMail.key), senderPubKey, this.#keys.privateKey);
+                key = sodium.to_hex(fileKey);
+            }
+            else {
+                key = file.key;
+            }
+        }
+        else {
+            key = file.key;
+        }
+        key = sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#keys.publicKey, this.#keys.privateKey));
+        const nameKey = secretstreamKeygen();
+        const encryptedName = await encryptName(name, sodium.to_hex(nameKey));
+        const encryptedNameKey = sodium.to_hex(encryptCryptoBox(nameKey, this.#keys.publicKey, this.#keys.privateKey));
+        const saveInCloud = await this.#apiClient.cloud.saveInCloud.mutate({
+            fileId,
+            key,
+            nodeId: nodeId ?? null,
+            filename: encryptedName,
+            nameKey: encryptedNameKey,
+        });
+        const node = await apiNodeToExternalNodeFull(saveInCloud, this.#keys);
+        const me = node.parent?.users.find(([u]) => u.id === this.#client.app.userId);
+        if (me !== undefined && ['admin', 'write'].includes(me[1])) {
+            const others = node.parent?.users.filter(([u]) => u.id !== this.#client.app.userId) ??
+                [];
+            await Promise.all(others.map(async ([u, rights]) => await this.shareNode({
+                nodeId: node.id,
+                rights,
+                userId: u.id,
+            })));
+        }
+        return node;
+    }
+    perNode = async (nodeId, publicKey) => {
+        let node = nodesCache.get(nodeId);
+        if (node === undefined) {
+            await this.node({ id: nodeId });
+            node = nodesCache.get(nodeId);
+            if (node === undefined) {
+                return null;
+            }
+        }
+        const nameKey = node.access?.nameKey;
+        if (nameKey === null) {
+            return null;
+        }
+        return {
+            id: node.id,
+            nameKey: sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), publicKey, this.#keys.privateKey)),
+            files: 'history' in node
+                ? node.history.map((f) => ({
+                    id: f.id,
+                    key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), publicKey, this.#keys.privateKey)),
+                }))
+                : [],
+        };
+    };
+}