web-dc-api 0.0.58 → 0.0.60

package/dist/esm/implements/dc/client.js

@@ -0,0 +1,43 @@
+import { Libp2pGrpcClient } from 'grpc-libp2p-client';
+import { dcnet } from '../../proto/dcnet_proto.js';
+import { base58btc } from '../../node_modules/multiformats/dist/src/bases/base58.js';
+import { toString } from '../../node_modules/uint8arrays/dist/src/to-string.js';
+
+class DCClient {
+  constructor(dcClient, peerAddr) {
+    Object.defineProperty(this, "client", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.client = dcClient;
+  }
+  async getHostID(peerAddr) {
+    try {
+      if (this.client.p2pNode == null) {
+        throw new Error("p2pNode is null");
+      }
+      if (!peerAddr) {
+        peerAddr = this.client.peerAddr;
+      }
+      const message = new dcnet.pb.GetHostIDRequest({});
+      const messageBytes = dcnet.pb.GetHostIDRequest.encode(message).finish();
+      const grpcClient = new Libp2pGrpcClient(this.client.p2pNode, peerAddr || this.client.peerAddr, this.client.token, this.client.protocol);
+      const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/GetHostID", messageBytes, 30000);
+      const decoded = dcnet.pb.GetHostIDReply.decode(responseData);
+      const encodedPeerid = base58btc.encode(decoded.peerID);
+      const encodedReqAddr = toString(decoded.reqAddr);
+      const reply = {
+        peerID: encodedPeerid,
+        reqAddr: encodedReqAddr
+      };
+      return reply;
+    } catch (err) {
+      console.error("getHostID error:", err);
+      throw err;
+    }
+  }
+}
+
+export { DCClient };

package/dist/esm/implements/dc/manager.js

@@ -0,0 +1,33 @@
+import { DCClient } from './client.js';
+
+// 错误定义
+class DCError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DCError";
+  }
+}
+const Errors = {
+  ErrNoDcPeerConnected: new DCError("no dc peer connected")
+};
+class DCManager {
+  constructor(connectedDc) {
+    Object.defineProperty(this, "connectedDc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+    this.connectedDc = connectedDc;
+  }
+  async getHostID(peerAddr) {
+    if (!this.connectedDc?.client) {
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    const dcClient = new DCClient(this.connectedDc.client);
+    const reply = await dcClient.getHostID(peerAddr);
+    return [reply, null];
+  }
+}
+
+export { DCError, DCManager, Errors };

package/dist/esm/implements/file/client.js

@@ -0,0 +1,208 @@
+import { Libp2pGrpcClient } from 'grpc-libp2p-client';
+import { dcnet } from '../../proto/dcnet_proto.js';
+import { uint64ToLittleEndianBytes, uint32ToLittleEndianBytes } from '../../util/utils.js';
+import { UploadStatus } from '../../common/types/types.js';
+
+const uploadRespondStatus = {
+  FilePulling: 3,
+  //文件拉取中
+  PullFail: 4,
+  //拉取失败
+  PullSuccess: 5,
+  //拉取成功
+  BlockFinality: 6,
+  //区块已经最终
+  FinalityTimeout: 7,
+  //最终化超时
+  FaultSize: 8,
+  //文件大小错误
+  FaultCount: 9,
+  //文件总数错误
+  NoUserSpace: 10,
+  //用户存储空间不足
+  NoPeerSpace: 11,
+  //节点空间不足
+  SpaceExpire: 12,
+  //用户空间过期
+  Error: 13,
+  //内部错误
+  TooManyBackups: 14,
+  //备份过多
+  VAccountParseError: 15 //Virth Account解析错误
+};
+class FileClient {
+  constructor(dcClient, dcNodeClient, context) {
+    Object.defineProperty(this, "client", {
+      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
+    });
+    this.client = dcClient;
+    this.dcNodeClient = dcNodeClient;
+    this.context = context;
+  }
+  async storeFile(fileSize, blockHeight, cid, peerId, onUpdateTransmitSize, onErrorCallback) {
+    const sizeValue = uint64ToLittleEndianBytes(fileSize);
+    const bhValue = uint32ToLittleEndianBytes(blockHeight ? blockHeight : 0);
+    const typeValue = uint32ToLittleEndianBytes(1);
+    // 将字符串 (dc.ConnectedDc.peerid) 转换为字节数组
+    const peerIdValue = new TextEncoder().encode(peerId);
+    const cidIdValue = new TextEncoder().encode(cid);
+    // 组合所有部分
+    const messageParts = new Uint8Array([...cidIdValue, ...sizeValue, ...bhValue, ...typeValue, ...peerIdValue]);
+    const signature = await this.context.sign(messageParts);
+    try {
+      if (this.client.p2pNode == null) {
+        throw new Error("p2pNode is null");
+      }
+      const message = new dcnet.pb.StroeFileRequest({});
+      message.cid = new TextEncoder().encode(cid);
+      message.filesize = fileSize;
+      message.blockheight = blockHeight;
+      message.signature = signature;
+      const messageBytes = dcnet.pb.StroeFileRequest.encode(message).finish();
+      //  const signatureDataSource = new DataSource();
+      const onDataCallback = async payload => {
+        const decodedPayload = dcnet.pb.StroeFileReply.decode(payload);
+        let resStatus = UploadStatus.UPLOADING;
+        switch (decodedPayload.status) {
+          case uploadRespondStatus.FilePulling:
+            resStatus = UploadStatus.UPLOADING;
+            break;
+          case uploadRespondStatus.PullFail:
+            resStatus = UploadStatus.PULLERROR;
+            break;
+          case uploadRespondStatus.PullSuccess:
+            resStatus = UploadStatus.OK;
+            break;
+          case uploadRespondStatus.BlockFinality:
+            resStatus = UploadStatus.OK;
+            break;
+          case uploadRespondStatus.FinalityTimeout:
+            resStatus = UploadStatus.ABNORMAL;
+            break;
+          case uploadRespondStatus.FaultSize:
+            resStatus = UploadStatus.FILESIZEERROR;
+            break;
+          case uploadRespondStatus.FaultCount:
+            resStatus = UploadStatus.FILECOUNTERROR;
+            break;
+          case uploadRespondStatus.NoUserSpace:
+            resStatus = UploadStatus.NOSPACE;
+            break;
+        }
+        if (onUpdateTransmitSize) {
+          onUpdateTransmitSize(resStatus, Number(decodedPayload.receivesize));
+        }
+      };
+      // const dataSourceCallback = (): AsyncIterable<Uint8Array> => {
+      //   console.log("dataSourceCallback");
+      //   return signatureDataSource.getDataSource();
+      // };
+      // 使用方法
+      const grpcClient = new Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+      await grpcClient.Call("/dcnet.pb.Service/StoreFile", messageBytes, 100000, "server-streaming", onDataCallback);
+      return;
+      // const decoded = dcnet.pb.StroeFileReply.decode(responseData);
+      // return [decoded.cid, decoded.decryptKey, null];
+    } catch (err) {
+      console.error("storeFile error:", err);
+      throw err;
+    }
+  }
+  /**
+   * Stores a folder on the DC network
+   * @param id - CID of the folder to store
+   * @param options - File options including signature, size, etc.
+   * @returns AsyncIterable that yields storage status updates
+   */
+  async storeFolder(cid, options, updateTransmitCount, onErrorCallback) {
+    try {
+      // Check client
+      if (this.client.p2pNode == null) {
+        throw new Error("p2pNode is null");
+      }
+      // Create the request message
+      const message = new dcnet.pb.StoreFolderRequest({
+        cid: new TextEncoder().encode(cid),
+        filecount: options.fileCount,
+        foldersize: options.fileSize,
+        blockheight: options.blockHeight,
+        signature: options.signature
+      });
+      // Add virtual account if provided
+      if (options.vaccount) {
+        try {
+          message.vaccount = options.vaccount.pubKeyRaw;
+        } catch (error) {
+          throw new Error("Failed to parse virtual account: " + error.message);
+        }
+      }
+      // Encode the message
+      const messageBytes = dcnet.pb.StoreFolderRequest.encode(message).finish();
+      const onDataCallback = async payload => {
+        try {
+          const decodedPayload = dcnet.pb.StoreFolderReply.decode(payload);
+          let resStatus = UploadStatus.UPLOADING;
+          switch (decodedPayload.status) {
+            case uploadRespondStatus.FilePulling:
+              resStatus = UploadStatus.UPLOADING;
+              break;
+            case uploadRespondStatus.PullFail:
+              resStatus = UploadStatus.PULLERROR;
+              break;
+            case uploadRespondStatus.PullSuccess:
+              resStatus = UploadStatus.OK;
+              break;
+            case uploadRespondStatus.BlockFinality:
+              resStatus = UploadStatus.OK;
+              break;
+            case uploadRespondStatus.FinalityTimeout:
+              resStatus = UploadStatus.ABNORMAL;
+              break;
+            case uploadRespondStatus.FaultSize:
+              resStatus = UploadStatus.FILESIZEERROR;
+              break;
+            case uploadRespondStatus.FaultCount:
+              resStatus = UploadStatus.FILECOUNTERROR;
+              break;
+            case uploadRespondStatus.NoUserSpace:
+              resStatus = UploadStatus.NOSPACE;
+              break;
+          }
+          if (updateTransmitCount !== null) {
+            updateTransmitCount(resStatus, options.fileCount, decodedPayload.receivecount);
+          }
+        } catch (error) {
+          console.error("Error decoding StoreFolderReply:", error);
+          if (onErrorCallback) {
+            onErrorCallback(new Error("Failed to decode StoreFolderReply: " + error.message));
+          }
+        }
+      };
+      // 使用方法
+      const grpcClient = new Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+      await grpcClient.Call("/dcnet.pb.Service/StoreFolder", messageBytes, 100000, "server-streaming", onDataCallback);
+    } catch (err) {
+      console.error("storeFolder error:", err);
+      if (onErrorCallback) {
+        onErrorCallback(new Error("StoreFolder failed: " + (err instanceof Error ? err.message : String(err))));
+      }
+    }
+  }
+}
+
+export { FileClient };

package/dist/esm/implements/file/file-cache-manager.js

@@ -0,0 +1,140 @@
+import { createLogger } from '../../util/logger.js';
+
+// file-cache-manager.ts
+// 文件缓存管理工具
+const logger = createLogger('FileCacheManager');
+/**
+ * 文件缓存管理器
+ * 负责管理可寻址文件流的缓存，提高性能并减少网络负担
+ */
+class FileCacheManager {
+  /**
+   * 创建文件缓存管理器
+   * @param timeout 缓存超时时间(毫秒)，默认100秒
+   */
+  constructor() {
+    let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100000;
+    // 文件缓存相关属性
+    Object.defineProperty(this, "seekableFileStreamCache", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: new Map()
+    });
+    Object.defineProperty(this, "CACHE_TIMEOUT", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "cacheCleanupInterval", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    this.CACHE_TIMEOUT = timeout;
+    this.startCacheCleanupTask();
+  }
+  /**
+   * 获取缓存的文件流，如果不存在则返回null
+   * @param ipfsPath IPFS路径
+   * @param decryptKey 解密密钥
+   * @returns 缓存的文件流或null
+   */
+  getCachedFileStream(ipfsPath, decryptKey) {
+    const cacheKey = `${ipfsPath}_${decryptKey}`;
+    const cachedItem = this.seekableFileStreamCache.get(cacheKey);
+    if (cachedItem) {
+      logger.info(`使用缓存的SeekableFileStream: ${cacheKey}`);
+      // 更新最后访问时间
+      cachedItem.lastAccessTime = Date.now();
+      return cachedItem.stream;
+    }
+    return null;
+  }
+  /**
+   * 将文件流添加到缓存
+   * @param ipfsPath IPFS路径
+   * @param decryptKey 解密密钥
+   * @param fileStream 文件流对象
+   */
+  cacheFileStream(ipfsPath, decryptKey, fileStream) {
+    const cacheKey = `${ipfsPath}_${decryptKey}`;
+    logger.info(`创建新的SeekableFileStream缓存: ${cacheKey}`);
+    // 将新创建的流保存到缓存，并记录访问时间
+    this.seekableFileStreamCache.set(cacheKey, {
+      stream: fileStream,
+      lastAccessTime: Date.now()
+    });
+  }
+  /**
+   * 清理文件缓存
+   * @param pathname 可选，指定要清理的路径
+   */
+  clearFileCache(pathname) {
+    if (pathname) {
+      // 清理特定路径的缓存
+      const pathParts = pathname.split('/');
+      let ipfsPath = pathParts[3];
+      const keyParts = ipfsPath.split('_');
+      if (keyParts.length > 1) {
+        ipfsPath = keyParts[0];
+        const decryptKey = keyParts[1];
+        const cacheKey = `${ipfsPath}_${decryptKey}`;
+        this.seekableFileStreamCache.delete(cacheKey);
+        logger.info(`清理特定缓存: ${cacheKey}`);
+      }
+    } else {
+      // 清理所有缓存
+      this.seekableFileStreamCache.clear();
+      logger.info('清理所有文件缓存');
+    }
+  }
+  /**
+   * 启动定时缓存清理任务
+   * 超过设定时间未访问的流将被释放
+   */
+  startCacheCleanupTask() {
+    if (this.cacheCleanupInterval) {
+      clearInterval(this.cacheCleanupInterval);
+    }
+    this.cacheCleanupInterval = setInterval(() => {
+      const now = Date.now();
+      let removedCount = 0;
+      // 检查所有缓存项是否超时
+      for (const [key, value] of this.seekableFileStreamCache.entries()) {
+        if (now - value.lastAccessTime > this.CACHE_TIMEOUT) {
+          // 超过设定时间没有访问，释放资源
+          logger.info(`缓存超时，释放资源: ${key}`);
+          this.seekableFileStreamCache.delete(key);
+          removedCount++;
+        }
+      }
+      if (removedCount > 0 || this.seekableFileStreamCache.size > 0) {
+        logger.info(`文件缓存清理: 移除 ${removedCount} 项，剩余 ${this.seekableFileStreamCache.size} 项`);
+      }
+    }, 5000); // 每5秒检查一次超时缓存
+  }
+  /**
+   * 停止缓存清理任务
+   */
+  stopCacheCleanupTask() {
+    if (this.cacheCleanupInterval) {
+      clearInterval(this.cacheCleanupInterval);
+      this.cacheCleanupInterval = null;
+    }
+  }
+  /**
+   * 获取缓存状态信息
+   * @returns 缓存状态信息对象
+   */
+  getCacheStats() {
+    return {
+      total: this.seekableFileStreamCache.size,
+      keys: Array.from(this.seekableFileStreamCache.keys())
+    };
+  }
+}
+
+export { FileCacheManager };