web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/implements/file/manager.js

@@ -0,0 +1,994 @@
+'use strict';
+
+var types = require('../../common/types/types.js');
+var client$1 = require('./client.js');
+var utils = require('../../util/utils.js');
+var unixfs = require('@helia/unixfs');
+var key = require('../threaddb/common/key.js');
+var cid = require('../../node_modules/multiformats/dist/src/cid.js');
+var dcutil = require('../../common/dcutil.js');
+var toBuffer = require('it-to-buffer');
+var dccrypt = require('../../util/dccrypt.js');
+var index = require('../../_virtual/index.js');
+var index$1 = require('../../node_modules/uint8arraylist/dist/src/index.js');
+var constants = require('../../common/constants.js');
+var seekableFileStream = require('./seekableFileStream.js');
+var client = require('../account/client.js');
+
+const {
+  Buffer
+} = index;
+const NonceBytes = 12;
+const TagBytes = 16;
+const dcFileHead = "$$dcfile$$";
+const chunkSize = 3 * 1024 * 1024; // 3MB chunks
+// 创建一个可以取消的信号
+const controller = new AbortController();
+const {
+  signal
+} = controller;
+// 错误定义
+class FileError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FileError";
+  }
+}
+const Errors = {
+  ErrNoDcPeerConnected: new FileError("no dc peer connected"),
+  ErrNoFileChose: new FileError("no file choose"),
+  ErrNoPeerIdIsNull: new FileError("peerId is null"),
+  ErrNoNeedUpload: new FileError("no need upload"),
+  ErrPublicKeyIsNull: new FileError("publickey is null")
+};
+class FileManager {
+  constructor(dc, connectedDc, chainUtil, dcNodeClient, context) {
+    Object.defineProperty(this, "dc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "connectedDc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+    Object.defineProperty(this, "chainUtil", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dcNodeClient", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    // 从dc网络获取指定文件
+    // flag 是否需要连接节点，0-需要，1-不需要
+    Object.defineProperty(this, "getFileFromDc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async (cid$1, decryptKey, flag, folderFlag) => {
+        if (flag !== constants.cidNeedConnect.NOT_NEED) {
+          const [multiAddrs, peers] = await this.dc?._connectToObjNodes(cid$1);
+          if (!multiAddrs && peers) {
+            // 有peers但是没有multiaddrs
+            return null;
+          }
+        }
+        const fs = unixfs.unixfs(this.dcNodeClient);
+        let headDealed = false;
+        let waitBuffer = new Uint8Array(0);
+        let fileContent = new Uint8Array(0);
+        const encryptextLen = (3 << 20) + NonceBytes + TagBytes; //每段密文长度(最后一段可能会短一点)
+        const catOptions = {
+          offset: 0,
+          length: 32
+          // signal: AbortSignal.timeout(5000),
+        };
+        let readCount = 0;
+        try {
+          for (;;) {
+            if (!headDealed && !folderFlag) {
+              const headBuf = await toBuffer(fs.cat(cid.CID.parse(cid$1), catOptions));
+              readCount += headBuf.length;
+              if (headBuf.length > 0) {
+                waitBuffer = utils.mergeUInt8Arrays(waitBuffer, headBuf);
+                if (waitBuffer.length < 32) {
+                  catOptions.offset = waitBuffer.length;
+                  catOptions.length = 32 - waitBuffer.length;
+                  continue;
+                } else {
+                  //判断是否是dc网络存储的文件头
+                  headDealed = true;
+                  if (utils.compareByteArrays(waitBuffer.subarray(0, 10), Buffer.from("$$dcfile$$"))) {
+                    //判断是否是dc网络存储的文件头
+                    waitBuffer = waitBuffer.subarray(32, waitBuffer.length);
+                  }
+                }
+              } else {
+                if (waitBuffer.length > 0) {
+                  if (decryptKey != "") {
+                    const decrypted = await dccrypt.decryptContent(waitBuffer, decryptKey);
+                    fileContent = utils.mergeUInt8Arrays(fileContent, decrypted);
+                  } else {
+                    fileContent = utils.mergeUInt8Arrays(fileContent, waitBuffer);
+                  }
+                }
+                break;
+              }
+              continue;
+            }
+            catOptions.offset = readCount;
+            catOptions.length = encryptextLen;
+            const buf = await toBuffer(fs.cat(cid.CID.parse(cid$1), catOptions));
+            if (buf.length > 0) {
+              readCount += buf.length;
+            }
+            if (buf.length > 0) {
+              waitBuffer = utils.mergeUInt8Arrays(waitBuffer, buf);
+              while (waitBuffer.length >= encryptextLen) {
+                const encryptBuffer = waitBuffer.subarray(0, encryptextLen);
+                waitBuffer = waitBuffer.subarray(encryptextLen, waitBuffer.length);
+                if (decryptKey == "") {
+                  fileContent = utils.mergeUInt8Arrays(fileContent, encryptBuffer);
+                  continue;
+                }
+                //解密
+                const decrypted = await dccrypt.decryptContent(encryptBuffer, decryptKey);
+                fileContent = utils.mergeUInt8Arrays(fileContent, decrypted);
+              }
+            } else {
+              if (waitBuffer.length > 0) {
+                if (decryptKey != "") {
+                  const decrypted = await dccrypt.decryptContent(waitBuffer, decryptKey);
+                  fileContent = utils.mergeUInt8Arrays(fileContent, decrypted);
+                } else {
+                  fileContent = utils.mergeUInt8Arrays(fileContent, waitBuffer);
+                }
+              }
+              break;
+            }
+          }
+          return fileContent;
+        } catch (error) {
+          console.error("getFileFromDc error", error);
+          return null;
+        }
+      }
+    });
+    this.dc = dc;
+    this.connectedDc = connectedDc;
+    this.chainUtil = chainUtil;
+    this.dcNodeClient = dcNodeClient;
+    this.context = context;
+  }
+  // 处理文件头
+  async _processHeader(pubkeyBytes, fileSize, content, isFirstChunk) {
+    if (isFirstChunk) {
+      // 计算 pubkey 的 hash
+      const pubkeyHash = await crypto.subtle.digest("SHA-256", pubkeyBytes);
+      const pubkeyHashArray = new Uint8Array(pubkeyHash);
+      // 创建文件头
+      const headArray = new TextEncoder().encode(dcFileHead);
+      const pubkeyHashPart = pubkeyHashArray.slice(10, 24);
+      // 创建表示文件大小的字节数组
+      const realSizeBuffer = utils.uint64ToBigEndianBytes(fileSize);
+      const realSizeBytes = new Uint8Array(realSizeBuffer);
+      // 组合所有部分
+      const result = new Uint8Array([...headArray, ...pubkeyHashPart, ...realSizeBytes, ...content]);
+      return result;
+    }
+    return content;
+  }
+  async _uploadLargeFileAdvanced(file) {
+    let resumeState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      offset: 0,
+      chunkHashes: []
+    };
+    let pubkeyBytes = arguments.length > 2 ? arguments[2] : undefined;
+    let symKey = arguments.length > 3 ? arguments[3] : undefined;
+    const fs = unixfs.unixfs(this.dcNodeClient);
+    let offset = resumeState.offset || 0;
+    resumeState.chunkHashes || {};
+    const _this = this;
+    // 创建符合流式接口的内容生成器
+    const contentStream = async function* () {
+      while (offset < file.size) {
+        // // 检查取消信号（需要补充signal参数）
+        // if (_this.signal?.aborted) {
+        //   throw new AbortError('Upload cancelled')
+        // }
+        // 读取分块
+        const chunk = file.slice(offset, offset + chunkSize);
+        const arrayBuffer = await chunk.arrayBuffer();
+        let content = new Uint8Array(arrayBuffer);
+        // 加密处理
+        if (symKey) {
+          content = await symKey.encrypt(content);
+        }
+        // 文件头处理（仅在第一个分块添加）
+        if (pubkeyBytes && offset === 0) {
+          content = await _this._processHeader(pubkeyBytes, file.size, content, true // isFirstChunk
+          );
+        }
+        offset += chunkSize;
+        yield content;
+      }
+    };
+    const cid = await fs.addByteStream(contentStream(), {
+      rawLeaves: false,
+      leafType: "file",
+      shardSplitThresholdBytes: 256 * 1024
+    });
+    return cid;
+  }
+  /**
+   * 检查当前连接的节点是否已经绑定到用户账户
+   * @returns 如果已绑定则返回true，否则返回false
+   */
+  async isAccessPeerIdBinded() {
+    const userInfo = await this.chainUtil.refreshUserInfo(this.context.getPubkeyRaw());
+    if (userInfo.requestPeers && userInfo.requestPeers.length > 0) {
+      for (const peerId of userInfo.requestPeers) {
+        // 已经是绑定节点，直接返回true
+        if (peerId === this.connectedDc.nodeAddr?.getPeerId()) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  // 上传文件
+  async addFile(file, enkey, onUpdateTransmitSize, vaccount) {
+    if (!this.connectedDc?.client) {
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    if (!this.connectedDc || !this.connectedDc.nodeAddr) {
+      console.error("=========Errors.ErrNoDcPeerConnected");
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    // this.dcNodeClient.libp2p.dialProtocol(this.connectedDc.nodeAddr, '/ipfs/bitswap/1.2.0')
+    const blockHeight = await this.chainUtil.getBlockHeight();
+    const peerId = this.connectedDc.nodeAddr?.getPeerId();
+    if (!peerId) {
+      return [null, Errors.ErrNoPeerIdIsNull];
+    }
+    let resCid = "";
+    try {
+      if (!(await this.isAccessPeerIdBinded())) {
+        // 检查当前连接的节点是否已经绑定到用户账户,没绑定,执行绑定
+        const accountClient = new client.AccountClient(this.connectedDc.client);
+        await accountClient.bindAccessPeerToUser(this.context, blockHeight ? blockHeight : 0, peerId);
+        //等待绑定信息上链,最多等待20秒
+        let waitCount = 0;
+        while (true) {
+          if (await this.isAccessPeerIdBinded()) {
+            break;
+          }
+          waitCount += 1;
+          if (waitCount > 30) {
+            return [null, new FileError("No access auth to peer")]; // 使用正确的错误返回格式
+          }
+          await utils.sleep(1000); // 使用毫秒，等同于1秒
+        }
+      }
+    } catch (error) {
+      return [null, error];
+    }
+    try {
+      const fileSize = file.size;
+      const symKey = enkey && enkey.length > 0 ? key.SymmetricKey.fromString(enkey) : null;
+      const fs = unixfs.unixfs(this.dcNodeClient);
+      const pubkeyBytes = this.context.getPubkeyRaw();
+      // const peerId = "12D3KooWEGzh4AcbJrfZMfQb63wncBUpscMEEyiMemSWzEnjVCPf";
+      let nodeAddr = await this.dc?._getNodeAddr(peerId);
+      if (!nodeAddr) {
+        return [null, Errors.ErrNoDcPeerConnected];
+      }
+      const cid = await this._uploadLargeFileAdvanced(file, {
+        offset: 0,
+        chunkHashes: []
+      }, pubkeyBytes, symKey);
+      if (!cid) {
+        return [resCid, Errors.ErrNoFileChose];
+      }
+      console.log("==========_uploadLargeFileAdvanced", cid.toString());
+      resCid = cid.toString();
+      console.log("=========resCid", resCid);
+      const stats = await fs.stat(cid);
+      const filesize = stats.unixfs?.fileSize() || 0;
+      console.log("=========stats", stats.localFileSize.toString(), stats.localFileSize.toString(), stats.fileSize.toString(), stats.dagSize.toString(), filesize.toString());
+      const dagFileSize = Number(stats.localDagSize);
+      const fileClient = new client$1.FileClient(this.connectedDc.client, this.dcNodeClient, this.context);
+      let resStatus = 0;
+      let resFlag = false;
+      let resError = null;
+      fileClient.storeFile(dagFileSize, blockHeight ? blockHeight : 0, resCid, peerId, (status, size) => {
+        resFlag = true;
+        resStatus = status;
+        onUpdateTransmitSize(status, size);
+      }, async error => {
+        resFlag = true;
+        resError = error;
+      });
+      //等待storeRes 为true
+      while (!resFlag) {
+        await utils.sleep(100);
+      }
+      if (resError) {
+        return [null, resError];
+      }
+      if (resStatus === types.UploadStatus.ERROR || resStatus === types.UploadStatus.ABNORMAL || resStatus === types.UploadStatus.NOSPACE || resStatus === types.UploadStatus.FILECOUNTERROR || resStatus === types.UploadStatus.FILESIZEERROR || resStatus === types.UploadStatus.PULLERROR) {
+        //上传失败，不需要操作
+        return [null, Errors.ErrNoNeedUpload];
+      }
+      //创建文件主动上报流
+      await this.dc.createTransferStream(this.dcNodeClient.libp2p, this.dcNodeClient.blockstore, nodeAddr, dcutil.BrowserType.File, resCid);
+    } catch (error) {
+      console.error("=========stream close", error);
+      throw error;
+    }
+    return [resCid, null];
+  }
+  /**
+   * Adds a folder to the DC network using browser FileList
+   * @param folderInput - Files from a directory input element
+   * @param enkey - Encryption key
+   * @param updateTransmitCount - Callback for progress updates
+   * @param vaccount - Optional virtual account
+   * @returns Promise with CID string and error if any
+   */
+  async addFolder(fileList, enkey, updateTransmitCount, vaccount) {
+    if (!this.connectedDc?.client) {
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    if (!this.connectedDc || !this.connectedDc.nodeAddr) {
+      console.error("=========Errors.ErrNoDcPeerConnected");
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    // this.dcNodeClient.libp2p.dialProtocol(this.connectedDc.nodeAddr, '/ipfs/bitswap/1.2.0')
+    const blockHeight = await this.chainUtil.getBlockHeight();
+    const peerId = this.connectedDc.nodeAddr?.getPeerId();
+    if (!peerId) {
+      return [null, Errors.ErrNoPeerIdIsNull];
+    }
+    let nodeAddr = await this.dc?._getNodeAddr(peerId);
+    if (!nodeAddr) {
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    try {
+      if (!(await this.isAccessPeerIdBinded())) {
+        // 检查当前连接的节点是否已经绑定到用户账户,没绑定,执行绑定
+        const accountClient = new client.AccountClient(this.connectedDc.client);
+        await accountClient.bindAccessPeerToUser(this.context, blockHeight ? blockHeight : 0, peerId);
+        //等待绑定信息上链,最多等待20秒
+        let waitCount = 0;
+        while (true) {
+          if (await this.isAccessPeerIdBinded()) {
+            break;
+          }
+          waitCount += 1;
+          if (waitCount > 30) {
+            return [null, new FileError("No access auth to peer")]; // 使用正确的错误返回格式
+          }
+          await utils.sleep(1000); // 使用毫秒，等同于1秒
+        }
+      }
+    } catch (error) {
+      return [null, error];
+    }
+    try {
+      // Create IPFS file system interface
+      const fs = unixfs.unixfs(this.dcNodeClient);
+      // Generate user flag file (dc_ownuser)
+      let pubkeyBytes = this.context.getPubkeyRaw();
+      // Create hash of public key for owner file
+      const pubkeyHash = await crypto.subtle.digest("SHA-256", pubkeyBytes);
+      const ownerFileContent = new Uint8Array(pubkeyHash);
+      // Create folder structure using MFS (memory file system)
+      // Get root folder name
+      const rootFolderName = this.extractRootFolderName(fileList);
+      //排除掉 dc_ownuser 文件,然后又加上去,防止重复添加
+      const files = Array.from(fileList).filter(file => file.name !== "dc_ownuser");
+      //将ownerFileContent作为文件内容,最后添加到根目录
+      const ownerPath = rootFolderName + "/dc_ownuser";
+      files.push(new File([ownerFileContent], "dc_ownuser", {
+        type: "text/plain"
+      }));
+      // 将文件路径与内容流映射
+      const source = Array.from(files).map(file => ({
+        path: file.name === "dc_ownuser" ? ownerPath : file.webkitRelativePath,
+        // 获取文件相对路径
+        content: this.fileToStream(file, enkey) // 使用文件流
+      }));
+      const results = fs.addAll(source);
+      let rootCID = null;
+      let totalSize = 0;
+      //  let fileCount = 0;
+      for await (const {
+        path,
+        size,
+        cid
+      } of results) {
+        // The entry with path equal to the root folder name is our root
+        if (path === rootFolderName) {
+          rootCID = cid;
+          totalSize = Number(size);
+        }
+      }
+      if (!rootCID) {
+        console.error("Failed to find root directory CID in IPFS results");
+        return [null, new Error("Failed to find root directory CID")];
+      }
+      // 获取rootCID下的块数量
+      const fileCount = await this.countDirectoryBlocks(rootCID);
+      // Get final node and CID
+      const finalCid = rootCID.toString();
+      const folderSize = totalSize;
+      // Sign folder data
+      const serverPidBytes = new TextEncoder().encode(peerId);
+      const sizeValue = utils.uint64ToLittleEndianBytes(folderSize);
+      const heightValue = utils.uint32ToLittleEndianBytes(blockHeight || 0);
+      const typeValue = utils.uint32ToLittleEndianBytes(1); // Folder type = 1
+      // Create signature payload
+      let preSign = new TextEncoder().encode(finalCid);
+      preSign = utils.mergeUInt8Arrays(preSign, sizeValue);
+      preSign = utils.mergeUInt8Arrays(preSign, heightValue);
+      preSign = utils.mergeUInt8Arrays(preSign, typeValue);
+      preSign = utils.mergeUInt8Arrays(preSign, serverPidBytes);
+      // Sign the data
+      const signature = await this.context.sign(preSign);
+      // Create file options
+      const fileOptions = {
+        signature,
+        blockHeight: blockHeight || 0,
+        fileSize: folderSize,
+        fileCount: fileCount,
+        pubkey: this.context.getPubkeyRaw(),
+        vaccount: ""
+      };
+      if (vaccount) {
+        fileOptions.vaccount = vaccount;
+      }
+      let client = this.connectedDc.client;
+      if (client === null) {
+        return ["", new Error("ErrConnectToAccountPeersFail")];
+      }
+      if (client.peerAddr === null) {
+        return ["", new Error("ErrConnectToAccountPeersFail")];
+      }
+      if (!this.context.publicKey) {
+        return [null, Errors.ErrPublicKeyIsNull];
+      }
+      if (client.token == "") {
+        await client.GetToken(this.context.appInfo.appId || "", this.context.publicKey.string(), this.context.sign);
+      }
+      // Store folder on DC network
+      const fileClient = new client$1.FileClient(this.connectedDc.client, this.dcNodeClient, this.context);
+      let resFlag = false;
+      let resStatus = 0;
+      let resError = null;
+      // Create channel for async communication
+      fileClient.storeFolder(rootCID.toString(), fileOptions, (status, total, processed) => {
+        resFlag = true;
+        resStatus = status;
+        updateTransmitCount(status, total, processed);
+      }, async error => {
+        resFlag = true;
+        resError = error;
+      });
+      while (!resFlag) {
+        await utils.sleep(100);
+      }
+      if (resError) {
+        updateTransmitCount(types.UploadStatus.ERROR, 0, 0);
+        return [null, resError];
+      }
+      if (resStatus === types.UploadStatus.ERROR || resStatus === types.UploadStatus.ABNORMAL || resStatus === types.UploadStatus.NOSPACE || resStatus === types.UploadStatus.FILECOUNTERROR || resStatus === types.UploadStatus.FILESIZEERROR || resStatus === types.UploadStatus.PULLERROR) {
+        //上传失败的时候，不需要操作
+        return [null, Errors.ErrNoNeedUpload];
+      }
+      //创建文件主动上报流
+      await this.dc.createTransferStream(this.dcNodeClient.libp2p, this.dcNodeClient.blockstore, nodeAddr, dcutil.BrowserType.File, finalCid);
+      return [finalCid, null];
+    } catch (error) {
+      console.error("Folder upload failed:", error);
+      return [null, error instanceof Error ? error : new Error(String(error))];
+    }
+  }
+  /**
+   * Creates a custom FileList object from file paths and contents
+   * @param filesMap - Map of file paths to content (string or Uint8Array)
+   * @param rootFolderName - Optional root folder name (defaults to "upload")
+   * @returns A FileList-like object that can be used with addFolder
+   */
+  createCustomFileList(filesMap) {
+    let rootFolderName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "upload";
+    // Convert object to Map if needed
+    const filesMapObj = filesMap instanceof Map ? filesMap : new Map(Object.entries(filesMap));
+    // Create File objects with proper webkitRelativePath
+    const files = [];
+    filesMapObj.forEach((content, path) => {
+      // Ensure path starts with rootFolderName
+      const fullPath = path.startsWith(rootFolderName) ? path : `${rootFolderName}/${path}`;
+      // Convert content to proper format
+      let fileContent;
+      if (typeof content === "string") {
+        fileContent = new Blob([content], {
+          type: "text/plain"
+        });
+      } else {
+        fileContent = new Blob([content]);
+      }
+      // Create File object with webkitRelativePath
+      // const file = new File([fileContent], path.split("/").pop() || "unnamed", {
+      //   type: "application/octet-stream",
+      // }) as File & { webkitRelativePath: string };
+      const file = Object.defineProperty(new File([fileContent], path.split("/").pop() || "unnamed", {
+        type: "application/octet-stream"
+      }), "webkitRelativePath", {
+        value: fullPath,
+        writable: false
+      });
+      // Set webkitRelativePath property
+      // file.webkitRelativePath = fullPath;
+      files.push(file);
+    });
+    // Create a FileList-like object
+    const fileListObj = {
+      length: files.length,
+      item(index) {
+        if (index < 0 || index >= files.length) {
+          return null; // Return null for out-of-bounds index
+        }
+        return files[index];
+      },
+      [Symbol.iterator]() {
+        let index = 0;
+        return {
+          next() {
+            if (index < files.length) {
+              return {
+                value: files[index++],
+                done: false
+              };
+            } else {
+              return {
+                value: null,
+                done: true
+              };
+            }
+          }
+        };
+      }
+    };
+    // Add files with their indices as keys
+    files.forEach((file, index) => {
+      fileListObj[index] = file;
+    });
+    const fileList = fileListObj;
+    return fileList;
+  }
+  fileToStream(file, enkey) {
+    const symKey = enkey ? key.SymmetricKey.fromString(enkey) : null;
+    const {
+      readable,
+      writable
+    } = new TransformStream();
+    const writer = writable.getWriter();
+    const fileReader = new FileReader();
+    const chunkSize = 3 << 20; // 3MB chunks
+    let offset = 0;
+    const processFile = async () => {
+      try {
+        while (offset < file.size) {
+          // Read chunk
+          const chunk = file.slice(offset, offset + chunkSize);
+          const buffer = await new Promise((resolve, reject) => {
+            fileReader.onload = () => resolve(fileReader.result);
+            fileReader.onerror = reject;
+            fileReader.readAsArrayBuffer(chunk);
+          });
+          const content = new Uint8Array(buffer);
+          // Encrypt if needed
+          if (symKey && file.name !== "dc_ownuser") {
+            const encrypted = await symKey.encrypt(content);
+            await writer.write(encrypted);
+          } else {
+            await writer.write(content);
+          }
+          offset += chunkSize;
+        }
+      } catch (error) {
+        console.error("Error processing file:", error);
+      } finally {
+        await writer.close();
+      }
+    };
+    // Start processing the file
+    processFile().catch(error => {
+      console.error("Error in file processing:", error);
+    });
+    return readable;
+  }
+  /**
+   * Counts all blocks recursively in a directory structure
+   * @param rootCID - The CID of the root directory
+   * @returns Promise with the total block count
+   */
+  async countDirectoryBlocks(rootCID) {
+    try {
+      const fs = unixfs.unixfs(this.dcNodeClient);
+      let totalBlocks = 0;
+      // Get stats for the root directory itself
+      const rootStats = await fs.stat(rootCID);
+      totalBlocks += Number(rootStats.blocks || 0);
+      // List all entries in the directory and process them recursively
+      for await (const entry of fs.ls(rootCID)) {
+        const {
+          cid,
+          type
+        } = entry;
+        // Get stats for the current entry
+        const stats = await fs.stat(cid);
+        if (type === "directory") {
+          // Recursively count blocks in subdirectories
+          const subDirBlocks = await this.countDirectoryBlocks(cid);
+          totalBlocks += subDirBlocks;
+        } else {
+          // For files, add their block count
+          totalBlocks += Number(stats.blocks || 0);
+        }
+      }
+      console.log(`Directory ${rootCID.toString()} contains ${totalBlocks} blocks`);
+      return totalBlocks;
+    } catch (error) {
+      console.error("Error counting directory blocks:", error);
+      throw error;
+    }
+  }
+  /**
+   * Extract the root folder name from a FileList
+   */
+  extractRootFolderName(files) {
+    if (files.length === 0) return "root";
+    const path = files[0].webkitRelativePath || files[0].name;
+    const parts = path.split("/");
+    return parts[0] || "root";
+  }
+  /**
+   * Create a folder in IPFS
+   */
+  async createFolderInIpfs(folderName) {
+    const fs = unixfs.unixfs(this.dcNodeClient);
+    const dirCid = await fs.addDirectory({
+      path: folderName
+    });
+    return dirCid;
+  }
+  /**
+   * Calculate the size of all files in a folder
+   */
+  calculateFolderSize(files) {
+    let totalSize = 0;
+    for (let i = 0; i < files.length; i++) {
+      totalSize += files[i].size;
+    }
+    return totalSize;
+  }
+  /**
+   * Adds a file to MFS file system folder with optional encryption
+   * @param parentDir - The parent directory in MFS
+   * @param dirPath - The directory path
+   * @param fileName - The name of the file
+   * @param enkey - Optional encryption key
+   * @returns Promise with result or error
+   */
+  async addFileToMfsFolder(parentDir,
+  // MFS Directory type (replace with actual type)
+  dirPath, fileName, enkey) {
+    let symKey = null;
+    const readPath = `${dirPath}/${fileName}`; // Use path joining appropriate for your env
+    try {
+      // Open file (implementation depends on environment - browser vs Node.js)
+      const fileContent = await this.readFile(readPath);
+      if (!fileContent) {
+        return [null, new Error("Could not open file")];
+      }
+      // Create encryption key if needed
+      if (enkey !== "") {
+        symKey = key.SymmetricKey.fromString(enkey);
+      }
+      // Create readable and writable streams for processing
+      const {
+        readable,
+        writable
+      } = new TransformStream();
+      const writer = writable.getWriter();
+      // Process the file in a separate async function (equivalent to goroutine)
+      (async () => {
+        try {
+          const file = await fetch(readPath).then(r => r.blob());
+          const fileReader = new FileReader();
+          const chunkSize = 1024;
+          let offset = 0;
+          while (offset < file.size) {
+            // Check for abort signal if needed
+            // if (signal?.aborted) throw new Error("Operation cancelled");
+            // Read chunk
+            const chunk = file.slice(offset, offset + chunkSize);
+            const buffer = await new Promise((resolve, reject) => {
+              fileReader.onload = () => resolve(fileReader.result);
+              fileReader.onerror = reject;
+              fileReader.readAsArrayBuffer(chunk);
+            });
+            const content = new Uint8Array(buffer);
+            // Encrypt if needed
+            if (symKey) {
+              const encrypted = await symKey.encrypt(content);
+              await writer.write(encrypted);
+            } else {
+              await writer.write(content);
+            }
+            offset += chunkSize;
+          }
+        } catch (error) {
+          console.error("Error processing file:", error);
+        } finally {
+          await writer.close();
+        }
+      })();
+      // Add file to IPFS
+      const fs = unixfs.unixfs(this.dcNodeClient);
+      const cid = await fs.addByteStream(this.streamToAsyncIterable(readable), {
+        rawLeaves: false,
+        leafType: "file",
+        shardSplitThresholdBytes: 256 * 1024
+      });
+      // Add to parent directory in MFS
+      await parentDir.addChild(fileName, cid);
+      await parentDir.flush();
+      return [cid.toString(), null];
+    } catch (error) {
+      return [null, error instanceof Error ? error : new Error(String(error))];
+    }
+  }
+  // Helper method to convert a ReadableStream to AsyncIterable
+  async *streamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        const {
+          done,
+          value
+        } = await reader.read();
+        if (done) break;
+        yield value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  // Helper to read a file (implementation depends on environment)
+  async readFile(path) {
+    try {
+      // Browser implementation example - replace with appropriate method
+      const response = await fetch(path);
+      return await response.blob();
+    } catch (error) {
+      console.error("Error reading file:", error);
+      return null;
+    }
+  }
+  async *chunkGenerator(stream) {
+    const iterator = stream.source[Symbol.asyncIterator]();
+    while (true) {
+      try {
+        const {
+          done,
+          value
+        } = await iterator.next();
+        if (done) break;
+        const res = value instanceof index$1.Uint8ArrayList ? value.subarray() : value;
+        yield res;
+      } catch (err) {
+        console.error("chunkGenerator error:", err);
+      }
+    }
+  }
+  /**
+   * 组装 CustomMessage 数据到 Uint8Array
+   * @param message - CustomMessage 包含消息的基本结构
+   * @returns Uint8Array - 序列化后的数据
+   */
+  assembleCustomMessage(message) {
+    // Step 1: header部分（1字节类型 + 2字节版本号 + 4字节payload长度）
+    const headerLength = 7; // Header固定长度：1字节Type + 2字节Version + 4字节Payload长度
+    const payloadLength = message.payload.byteLength;
+    const buffer = new Uint8Array(headerLength + payloadLength);
+    buffer[0] = message.type;
+    buffer[1] = message.version >> 8 & 0xff;
+    buffer[2] = message.version & 0xff;
+    buffer[3] = payloadLength >> 24 & 0xff;
+    buffer[4] = payloadLength >> 16 & 0xff;
+    buffer[5] = payloadLength >> 8 & 0xff;
+    buffer[6] = payloadLength & 0xff;
+    // Step 5: 设置 Payload 数据
+    buffer.set(message.payload, headerLength);
+    return buffer;
+  }
+  parseMessage(data) {
+    if (data.length < 7) {
+      return null;
+    }
+    // 第 1 字节: 消息类型
+    const type = data[0];
+    // 第 2 和 3 字节: 版本号（大端序）
+    const version = data[1] << 8 | data[2]; // 手动处理大端序
+    // 第 4 至 7 字节: payload 长度（大端序）
+    const payloadLength = data[3] << 24 | data[4] << 16 | data[5] << 8 | data[6];
+    // 验证数据完整性
+    if (data.length < 7 + payloadLength) {
+      return null;
+    }
+    // 提取 payload
+    const payload = data.slice(7, 7 + payloadLength); // 提取负载数据
+    return {
+      type,
+      version,
+      payload
+    };
+  }
+  /**
+   * 获取文件夹下的所有文件,包括内容（支持多级目录递归）
+   * @param cid 根目录的CID
+   * @param decryptKey 解密密钥
+   * @param recursive 是否递归获取子目录，默认false（保持向后兼容）
+   * @returns 文件列表：[{Name:文件或目录名，Type：0-文件 1-目录，Size：大小，Hash：文件或目录cid，Path：完整路径}]
+   */
+  async getFolderFileListWithContent(cid, decryptKey) {
+    let recursive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    const [fileList, err] = await this.getFolderFileList(cid, constants.cidNeedConnect.NEED, recursive);
+    if (err || !fileList) return [null, err];
+    for (let i = 0; i < fileList.length; i++) {
+      const file = fileList[i];
+      if (file?.Type === 0) {
+        if (file?.Name == "dc_ownuser") {
+          continue;
+        }
+        const content = await this.getFileFromDc(file.Hash, decryptKey, constants.cidNeedConnect.NOT_NEED, true); //和目录同节点,无需连接
+        if (!content) {
+          return [null, Errors.ErrNoFileChose];
+        }
+        file.Content = content;
+      }
+    }
+    return [fileList, null];
+  }
+  /**
+   * 获取文件夹下的文件列表（支持多级目录递归）
+   * @param cid 根目录的CID
+   * @param flag 是否需要连接节点
+   * @param recursive 是否递归获取子目录，默认false（保持向后兼容）
+   * @returns 返回JSON格式的文件列表：[{Name:文件或目录名，Type：0-文件 1-目录，Size：大小，Hash：文件或目录cid，Path：完整路径}]
+   */
+  async getFolderFileList(cid$1, flag) {
+    let recursive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    try {
+      const id = cid.CID.parse(cid$1);
+      if (flag !== constants.cidNeedConnect.NOT_NEED) {
+        const [multiAddrs, peers] = await this.dc?._connectToObjNodes(cid$1);
+        if (!multiAddrs && peers) {
+          // 有peers但是没有multiaddrs
+          return [null, Errors.ErrNoDcPeerConnected];
+        }
+      }
+      const fs = unixfs.unixfs(this.dcNodeClient);
+      const fileNodes = [];
+      // 递归获取目录内容的内部函数
+      const traverseDirectory = async function (dirCid) {
+        let currentPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+        // 遍历当前目录内容
+        for await (const entry of fs.ls(dirCid)) {
+          const {
+            name,
+            cid,
+            type
+          } = entry;
+          if (name === '.' || name === '..' || name === 'dc_ownuser') {
+            continue; // 跳过当前目录和上级目录
+          }
+          // 构建完整路径
+          const fullPath = currentPath ? `${currentPath}/${name}` : name;
+          // 获取文件/目录的统计信息
+          const stats = await fs.stat(cid);
+          // 构造文件信息对象
+          const fileInfo = {
+            Name: name,
+            Type: type === 'directory' ? 1 : 0,
+            // 0-文件 1-目录
+            Size: type === 'directory' ? 0 : Number(stats.fileSize || 0),
+            Hash: cid.toString(),
+            Path: fullPath
+          };
+          fileNodes.push(fileInfo);
+          // 如果是目录且需要递归，则继续遍历子目录
+          if (type === 'directory' && recursive) {
+            await traverseDirectory(cid, fullPath);
+          }
+        }
+      };
+      // 开始遍历
+      await traverseDirectory(id);
+      return [fileNodes, null];
+    } catch (error) {
+      console.error('获取文件夹列表失败:', error);
+      return [null, error instanceof Error ? error : new Error(String(error))];
+    }
+  }
+  /**
+   * 创建可随机访问的文件流
+   */
+  async createSeekableFileStream(cid$1, decryptKey, flag) {
+    // 连接到节点
+    if (flag !== constants.cidNeedConnect.NOT_NEED) {
+      const [multiAddrs, peers] = await this.dc?._connectToObjNodes(cid$1);
+      if (!multiAddrs && peers) {
+        // 有peers但是没有multiaddrs
+        return null;
+      }
+    }
+    const fs = unixfs.unixfs(this.dcNodeClient);
+    try {
+      // 读取头信息
+      const headerData = await toBuffer(fs.cat(cid.CID.parse(cid$1), {
+        offset: 0,
+        length: 32
+      }));
+      // 检查是否有DC文件头
+      const hasHeader = utils.compareByteArrays(headerData.subarray(0, 10), Buffer.from(dcFileHead));
+      // 获取文件大小
+      // const stats = await fs.stat(CID.parse(cid));
+      // const totalSize = Number(stats.fileSize);
+      const fileSize = this.readUint64BE(headerData, 24);
+      const fileInfo = {
+        size: fileSize,
+        hasHeader,
+        headerSize: hasHeader ? 32 : 0
+      };
+      // 创建并返回流对象
+      return new seekableFileStream.SeekableFileStream({
+        fileInfo,
+        fs,
+        cid: cid.CID.parse(cid$1),
+        decryptKey: decryptKey || "",
+        encryptChunkSize: (3 << 20) + NonceBytes + TagBytes
+      });
+    } catch (err) {
+      console.error("Failed to create seekable file stream:", err);
+      return null;
+    }
+  }
+  readUint64BE(buffer, offset) {
+    // JavaScript中Number可以安全表示的最大整数是2^53-1
+    const high = buffer[offset] * 2 ** 24 + buffer[offset + 1] * 2 ** 16 + buffer[offset + 2] * 2 ** 8 + buffer[offset + 3];
+    const low = buffer[offset + 4] * 2 ** 24 + buffer[offset + 5] * 2 ** 16 + buffer[offset + 6] * 2 ** 8 + buffer[offset + 7];
+    return high * 2 ** 32 + low;
+  }
+}
+
+exports.Errors = Errors;
+exports.FileError = FileError;
+exports.FileManager = FileManager;