bedrock-ts-sdk 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -522,7 +522,7 @@ var BedrockCore = class _BedrockCore {
    * Get the main account's public key
    */
   getPublicKey() {
-    return this.mainAccount.publicKey || "";
+    return this.encryptionPrivateKey.publicKey.compressed.toString("hex");
   }
   /**
    * Get the sub-account's private key (as hex string)
@@ -582,6 +582,9 @@ var BedrockCore = class _BedrockCore {
   }
 };
 
+// src/services/file-service.ts
+import { AlephHttpClient } from "@aleph-sdk/client";
+
 // src/crypto/encryption.ts
 import { encrypt as eciesEncrypt, decrypt as eciesDecrypt } from "eciesjs";
 var CryptoUtils = class {
@@ -875,7 +878,6 @@ var EncryptionService = class {
 };
 
 // src/services/file-service.ts
-import { AlephHttpClient } from "@aleph-sdk/client";
 var FileService = class {
   constructor(core) {
     this.core = core;
@@ -917,7 +919,7 @@ var FileService = class {
         }
         const encryptedContent = await EncryptionService.encryptFile(fileBuffer, key, iv);
         const storeResult = await aleph.uploadFile(encryptedContent);
-        const fullPath = directoryPath ? `${directoryPath}/${file.path}` : file.path;
+        const fullPath = directoryPath ? `${directoryPath}${file.path}` : file.path;
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         const fileMeta = {
           name: file.name,
@@ -968,12 +970,17 @@ var FileService = class {
    */
   async fetchFileEntries() {
     const aleph = this.core.getAlephService();
+    const privateKey = this.core.getSubAccountPrivateKey();
     try {
       const aggregate = await aleph.fetchAggregate(
         AGGREGATE_KEYS.FILE_ENTRIES,
         FileEntriesAggregateSchema
       );
-      return aggregate.files;
+      return aggregate.files.map(({ post_hash, path, shared_with }) => ({
+        post_hash,
+        path: EncryptionService.decryptEcies(path, privateKey),
+        shared_with
+      }));
     } catch (error) {
       throw new FileError(`Failed to fetch file entries: ${error.message}`);
     }
@@ -1297,12 +1304,13 @@ var FileService = class {
   // ============================================================================
   async saveFileEntries(files) {
     const aleph = this.core.getAlephService();
+    const publicKey = this.core.getPublicKey();
     await aleph.updateAggregate(
       AGGREGATE_KEYS.FILE_ENTRIES,
       FileEntriesAggregateSchema,
       async (aggregate) => {
         const newEntries = files.map((f) => ({
-          path: f.path,
+          path: EncryptionService.encryptEcies(f.path, publicKey),
           post_hash: f.post_hash,
           shared_with: f.shared_with || []
         }));
@@ -1314,15 +1322,17 @@ var FileService = class {
     const key = this.core.getEncryptionKey();
     const iv = EncryptionService.generateIv();
     const publicKey = this.core.getPublicKey();
+    const fileKey = Buffer.from(meta.key, "hex");
+    const fileIv = Buffer.from(meta.iv, "hex");
     return {
       name: await EncryptionService.encrypt(meta.name, key, iv),
-      path: EncryptionService.encryptEcies(meta.path, publicKey),
+      path: await EncryptionService.encrypt(meta.path, fileKey, fileIv),
       key: EncryptionService.encryptEcies(meta.key, publicKey),
       iv: EncryptionService.encryptEcies(meta.iv, publicKey),
-      store_hash: meta.store_hash,
+      store_hash: await EncryptionService.encrypt(meta.store_hash, fileKey, fileIv),
       size: await EncryptionService.encrypt(meta.size.toString(), key, iv),
       created_at: await EncryptionService.encrypt(meta.created_at, key, iv),
-      deleted_at: meta.deleted_at ? await EncryptionService.encrypt(meta.deleted_at, key, iv) : null,
+      deleted_at: await EncryptionService.encrypt(meta.deleted_at ?? "null", fileKey, fileIv),
       shared_keys: meta.shared_keys
     };
   }
@@ -1333,15 +1343,20 @@ var FileService = class {
     if (!privKey) {
       throw new EncryptionError("Private key not available");
     }
+    const decryptedKey = EncryptionService.decryptEcies(encryptedMeta.key, privKey);
+    const decryptedIv = EncryptionService.decryptEcies(encryptedMeta.iv, privKey);
+    const fileKey = Buffer.from(decryptedKey, "hex");
+    const fileIv = Buffer.from(decryptedIv, "hex");
+    const decryptedDeletedAt = await EncryptionService.decrypt(encryptedMeta.deleted_at, fileKey, fileIv);
     return {
       name: await EncryptionService.decrypt(encryptedMeta.name, key, iv),
-      path: EncryptionService.decryptEcies(encryptedMeta.path, privKey),
-      key: EncryptionService.decryptEcies(encryptedMeta.key, privKey),
-      iv: EncryptionService.decryptEcies(encryptedMeta.iv, privKey),
-      store_hash: encryptedMeta.store_hash,
+      path: await EncryptionService.decrypt(encryptedMeta.path, fileKey, fileIv),
+      key: decryptedKey,
+      iv: decryptedIv,
+      store_hash: await EncryptionService.decrypt(encryptedMeta.store_hash, fileKey, fileIv),
       size: parseInt(await EncryptionService.decrypt(encryptedMeta.size, key, iv)),
       created_at: await EncryptionService.decrypt(encryptedMeta.created_at, key, iv),
-      deleted_at: encryptedMeta.deleted_at ? await EncryptionService.decrypt(encryptedMeta.deleted_at, key, iv) : null,
+      deleted_at: decryptedDeletedAt === "null" ? null : decryptedDeletedAt,
       shared_keys: encryptedMeta.shared_keys || {}
     };
   }