web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/common/error.js

@@ -0,0 +1,67 @@
+'use strict';
+
+class AppError extends Error {
+  constructor(code, message) {
+    let statusCode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 400;
+    super(message);
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: code
+    });
+    Object.defineProperty(this, "statusCode", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: statusCode
+    });
+    this.name = code;
+  }
+}
+const Errors = {
+  // Authentication errors (400-499)
+  // INVALID_SIGNATURE: new AppError('INVALID_SIGNATURE', 'bad signature', 401),
+  INVALID_TOKEN: new AppError('INVALID_TOKEN', 'invalid token', 401),
+  // REQ_TOKEN_TOO_OFTEN: new AppError('REQ_TOKEN_TOO_OFTEN', 'request token too often', 429),
+  // user not bind to this peer
+  USER_NOT_BIND_TO_PEER: new AppError('USER_NOT_BIND_TO_PEER', 'user not bind to this peer'),
+  NO_USER_INFO: new AppError("NO_USER_INFO", "no user info found"),
+  NO_DC_PEER_CONNECTED: new AppError("NO_DC_PEER_CONNECTED", "no dc peer connected"),
+  FAIL_TO_GET_BLOCKHEIGHT: new AppError("FAIL_TO_GET_BLOCKHEIGHT", "fail to get blockheight"),
+  FAIL_TO_GET_TOKEN: new AppError("FAIL_TO_GET_TOKEN", "fail to get token"),
+  NO_CHAIN_UTIL: new AppError("NO_CHAIN_UTIL", "no chain util found")
+  // // User management errors
+  // USER_BINDED: new AppError('USER_BINDED', 'user has binded an account'),
+  // ACCOUNT_BINDED: new AppError('ACCOUNT_BINDED', 'account has been Binded with other user'),
+  // // Resource management errors
+  // NO_ENOUGH_USER_SPACE: new AppError('NO_ENOUGH_USER_SPACE', 'no enough user space', 507),
+  // DB_SPACE_LIMIT: new AppError('DB_SPACE_LIMIT', 'db space limit', 507),
+  // USER_SPACE_EXPIRED: new AppError('USER_SPACE_EXPIRED', 'store space has expired'),
+  // // Blockchain related errors
+  // BLOCKCHAIN_NOT_INIT: new AppError('BLOCKCHAIN_NOT_INIT', 'blockchain not init', 503),
+  // INVALID_ENCLAVE: new AppError('INVALID_ENCLAVE', 'invalid enclave'),
+  // // Network errors
+  // LOCAL_NET_FAIL: new AppError('LOCAL_NET_FAIL', 'local net fail', 502),
+  // // Thread management errors
+  // INVALID_THREADID: new AppError('INVALID_THREADID', 'invalid threadid'),
+  // THREAD_NOT_FOUND: new AppError('THREAD_NOT_FOUND', 'thread not found', 404),
+  // // Security errors
+  // INVALID_PRIVKEY: new AppError('INVALID_PRIVKEY', 'invalid privkey', 403),
+  // // Additional errors from original list
+  // INVALID_CID: new AppError('INVALID_CID', 'invalid cid'),
+  // PEER_NOT_INIT: new AppError('PEER_NOT_INIT', 'general datastore didn\'t init'),
+  // INVALID_IDENTITY: new AppError('INVALID_IDENTITY', 'invalid identity'),
+  // INVALID_REQUEST: new AppError('INVALID_REQUEST', 'invalid request', 400),
+  // INVALID_PEERID: new AppError('INVALID_PEERID', 'invalid peerid'),
+  // INVALID_PUBKEY: new AppError('INVALID_PUBKEY', 'invalid pubkey'),
+  // USER_NOT_OWN_THREAD: new AppError('USER_NOT_OWN_THREAD', 'user not own thread', 403),
+  // SUB_ACCOUNT_EXIST: new AppError('SUB_ACCOUNT_EXIST', 'sub account exist'),
+  // SELF_IS_SUB_ACCOUNT: new AppError('SELF_IS_SUB_ACCOUNT', 'self is sub account'),
+  // INVALID_SUB_ACCOUNT: new AppError('INVALID_SUB_ACCOUNT', 'invalid sub account'),
+  // INVALID_TEE_REPORT: new AppError('INVALID_TEE_REPORT', 'invalid tee report'),
+  // VACOUNT_MISMATCH: new AppError('VACOUNT_MISMATCH', 'vaccount mismatch')
+};
+
+exports.AppError = AppError;
+exports.Errors = Errors;

package/dist/cjs/common/grpc-dc.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var dcnet_proto = require('../proto/dcnet_proto.js');
+var grpcLibp2pClient = require('grpc-libp2p-client');
+var datasource = require('../proto/datasource.js');
+
+class DCGrpcClient {
+  constructor(node, peerAddr, token, protocol) {
+    Object.defineProperty(this, "grpcClient", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "token", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.grpcClient = new grpcLibp2pClient.Libp2pGrpcClient(node, peerAddr, token, protocol);
+    this.token = token;
+  }
+  async GetToken(appId, pubkey, signCallback) {
+    let token = "";
+    try {
+      let error = null;
+      const signatureDataSource = new datasource.DataSource();
+      const message = new dcnet_proto.dcnet.pb.GetTokenRequest({});
+      message.key = appId + "_" + pubkey;
+      const messageBytes = dcnet_proto.dcnet.pb.GetTokenRequest.encode(message).finish();
+      const onDataCallback = async payload => {
+        const decodedPayload = dcnet_proto.dcnet.pb.GetTokenReply.decode(payload);
+        if (decodedPayload.challenge) {
+          const challenge = decodedPayload.challenge;
+          const signature = await signCallback(challenge);
+          const message = new dcnet_proto.dcnet.pb.GetTokenRequest({});
+          message.signature = signature;
+          const messageBytes = dcnet_proto.dcnet.pb.GetTokenRequest.encode(message).finish();
+          signatureDataSource.setData(messageBytes);
+        } else if (decodedPayload.token) {
+          //获取到token
+          console.log("GetToken success");
+          token = decodedPayload.token;
+          signatureDataSource.close(); //关闭数据源
+        }
+      };
+      // 使用方法
+      const dataSourceCallback = () => {
+        console.log("dataSourceCallback");
+        return signatureDataSource.getDataSource();
+      };
+      const onEndCallback = async () => {
+        signatureDataSource.close();
+      };
+      const onErrorCallback = async err => {
+        console.log("onErrorCallback", err);
+        error = err instanceof Error ? err : new Error(String(err));
+        signatureDataSource.close();
+      };
+      await this.grpcClient.Call("/dcnet.pb.Service/GetToken", messageBytes, 30000, "bidirectional", onDataCallback, dataSourceCallback, onEndCallback, onErrorCallback);
+      if (error) {
+        throw error;
+      }
+      this.token = token;
+      this.grpcClient.setToken(token);
+      return token;
+    } catch (err) {
+      throw err;
+    }
+  }
+  async ValidToken() {
+    try {
+      const message = new dcnet_proto.dcnet.pb.ValidTokenRequest({});
+      const messageBytes = dcnet_proto.dcnet.pb.ValidTokenRequest.encode(message).finish();
+      const responseData = await this.grpcClient.unaryCall("/dcnet.pb.Service/ValidToken", messageBytes, 30000);
+      dcnet_proto.dcnet.pb.ValidTokenReply.decode(responseData);
+      return true;
+    } catch (err) {
+      throw err;
+    }
+  }
+}
+
+exports.DCGrpcClient = DCGrpcClient;

package/dist/cjs/common/module-system.js

@@ -0,0 +1,172 @@
+'use strict';
+
+var logger$1 = require('../util/logger.js');
+
+// module-system.ts
+// 定义模块注册和管理系统
+const logger = logger$1.createLogger("ModuleSystem");
+/**
+ * 核心模块名称枚举
+ */
+exports.CoreModuleName = void 0;
+(function (CoreModuleName) {
+  CoreModuleName["FILE"] = "file";
+  CoreModuleName["AUTH"] = "auth";
+  CoreModuleName["COMMENT"] = "comment";
+  CoreModuleName["DATABASE"] = "database";
+  CoreModuleName["MESSAGE"] = "message";
+  CoreModuleName["KEYVALUE"] = "keyvalue";
+  CoreModuleName["CACHE"] = "cache";
+  CoreModuleName["CLIENT"] = "client";
+  CoreModuleName["AIPROXY"] = "aiproxy";
+  CoreModuleName["UTIL"] = "util";
+})(exports.CoreModuleName || (exports.CoreModuleName = {}));
+/**
+ * 模块系统
+ * 负责管理和协调所有功能模块
+ */
+class ModuleSystem {
+  /**
+   * 创建模块系统
+   * @param context DC上下文
+   */
+  constructor(context) {
+    Object.defineProperty(this, "modules", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: new Map()
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "initialized", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: false
+    });
+    this.context = context;
+  }
+  /**
+   * 注册模块
+   * @param module 要注册的模块
+   * @returns 是否注册成功
+   */
+  registerModule(module) {
+    if (this.modules.has(module.moduleName)) {
+      logger.warn(`模块 ${module.moduleName} 已存在，无法重复注册`);
+      return false;
+    }
+    this.modules.set(module.moduleName, module);
+    return true;
+  }
+  /**
+   * 获取模块
+   * @param moduleName 模块名称
+   * @returns 模块实例或undefined
+   */
+  getModule(moduleName) {
+    return this.modules.get(moduleName);
+  }
+  /**
+   * 初始化所有已注册的模块
+   * @returns 是否所有模块都成功初始化
+   */
+  async initializeAll() {
+    logger.info("开始初始化所有模块...");
+    // 按照特定顺序初始化核心模块
+    const initOrder = [exports.CoreModuleName.AUTH,
+    // 认证模块优先，因为其他模块可能依赖认证
+    exports.CoreModuleName.FILE,
+    // 文件模块其次，许多功能依赖文件操作
+    exports.CoreModuleName.DATABASE,
+    // 数据库模块
+    exports.CoreModuleName.COMMENT,
+    // 评论模块
+    exports.CoreModuleName.MESSAGE,
+    // 消息模块
+    exports.CoreModuleName.KEYVALUE,
+    // 键值存储模块
+    exports.CoreModuleName.CLIENT,
+    // 客户端模块
+    exports.CoreModuleName.CACHE,
+    // 缓存模块
+    exports.CoreModuleName.AIPROXY,
+    // AIProxy模块
+    exports.CoreModuleName.UTIL // 工具模块
+    ];
+    // 先初始化核心模块
+    for (const moduleName of initOrder) {
+      const module = this.modules.get(moduleName);
+      if (module) {
+        try {
+          const success = await module.initialize(this.context);
+          if (!success) {
+            logger.error(`核心模块 ${moduleName} 初始化失败`);
+            return false;
+          }
+          logger.info(`核心模块 ${moduleName} 初始化成功`);
+        } catch (error) {
+          logger.error(`核心模块 ${moduleName} 初始化出错:`, error);
+          return false;
+        }
+      }
+    }
+    // 然后初始化其余的扩展模块
+    for (const [name, module] of this.modules.entries()) {
+      if (!initOrder.includes(name)) {
+        logger.info(`初始化扩展模块: ${name}`);
+        try {
+          const success = await module.initialize(this.context);
+          if (!success) {
+            logger.error(`扩展模块 ${name} 初始化失败`);
+            return false;
+          }
+        } catch (error) {
+          logger.error(`扩展模块 ${name} 初始化出错:`, error);
+          return false;
+        }
+      }
+    }
+    this.initialized = true;
+    logger.info("所有模块初始化完成");
+    return true;
+  }
+  /**
+   * 关闭所有模块
+   */
+  async shutdownAll() {
+    logger.info("开始关闭所有模块...");
+    // 逆序关闭模块
+    const modules = Array.from(this.modules.entries());
+    for (let i = modules.length - 1; i >= 0; i--) {
+      const [name, module] = modules[i];
+      try {
+        logger.info(`关闭模块: ${name}`);
+        await module.shutdown();
+      } catch (error) {
+        logger.error(`关闭模块 ${name} 时出错:`, error);
+      }
+    }
+    this.initialized = false;
+    logger.info("所有模块已关闭");
+  }
+  /**
+   * 检查模块系统是否已初始化
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * 获取已注册的模块列表
+   */
+  getRegisteredModules() {
+    return Array.from(this.modules.keys());
+  }
+}
+
+exports.ModuleSystem = ModuleSystem;

package/dist/cjs/common/service-worker.js

@@ -0,0 +1,227 @@
+'use strict';
+
+var logger$1 = require('../util/logger.js');
+
+// service-worker.ts
+// 负责处理 Service Worker 相关的功能
+const logger = logger$1.createLogger('ServiceWorker');
+/**
+ * 注册 Service Worker 并设置消息监听器
+ * @param fileOps 文件操作对象，用于处理IPFS请求
+ * @returns Promise<ServiceWorkerRegistration | null>
+ */
+async function registerServiceWorker(fileOps) {
+  let swUrl = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  if ('serviceWorker' in navigator) {
+    try {
+      // const registration = await navigator.serviceWorker.register(
+      //   new URL('/sw.js', import.meta.url).href
+      // );
+      if (window.location.protocol != 'https:' && window.location.hostname != 'localhost') {
+        logger.error('ServiceWorker 仅支持https协议');
+        return null;
+      }
+      // 路径在函数内部解析，不在模块顶层
+      const swPath = typeof window !== 'undefined' ? new URL(swUrl || '/sw.js', window.location.origin).href : '/sw.js';
+      const registration = await navigator.serviceWorker.register(swPath);
+      // 让等待中的 SW 立即成为激活态
+      if (registration.waiting) {
+        registration.waiting.postMessage({
+          type: 'SKIP_WAITING'
+        });
+      }
+      // 有新 SW 安装后自动接管
+      registration.addEventListener('updatefound', () => {
+        const nw = registration.installing;
+        if (!nw) return;
+        nw.addEventListener('statechange', () => {
+          if (nw.state === 'installed' && navigator.serviceWorker.controller) {
+            nw.postMessage({
+              type: 'SKIP_WAITING'
+            });
+          }
+        });
+      });
+      // 设置消息监听器处理IPFS资源请求
+      navigator.serviceWorker.addEventListener('message', async event => {
+        if (event.data && event.data.type === 'ipfs-fetch') {
+          await handleIpfsRequest(event.data, event.ports[0], fileOps);
+        }
+      });
+      // 控制器变化（新 SW 接管）
+      navigator.serviceWorker.addEventListener('controllerchange', () => {
+        location.reload();
+      });
+      return registration;
+    } catch (error) {
+      logger.error('ServiceWorker 注册失败:', error);
+      return null;
+    }
+  }
+  return Promise.reject('Service Worker not supported');
+}
+/**
+ * 处理IPFS请求
+ * @param data 请求数据
+ * @param port 消息端口
+ * @param fileOps 文件操作对象
+ */
+async function handleIpfsRequest(data, port, fileOps) {
+  const {
+    id,
+    pathname,
+    range
+  } = data;
+  let fileSize = 0;
+  try {
+    // 从路径提取IPFS路径和解密密钥
+    const pathParts = pathname.split('/');
+    let ipfsPath = pathParts[3]; // <ipfs-hash>[_<key>]
+    // 提取加密密钥（如果有）
+    let decryptKey = '';
+    const keyParts = ipfsPath.split('_');
+    if (keyParts.length > 1) {
+      ipfsPath = keyParts[0];
+      decryptKey = keyParts[1];
+    }
+    let fileData = null;
+    const DEFAULT_CHUNK_SIZE = 3 * 1024 * 1024; // 默认返回3MB数据块
+    let start = 0;
+    let end = 0;
+    if (fileOps) {
+      if (range) {
+        // 处理范围请求（视频跳转等）
+        try {
+          const fileStream = await fileOps.getSeekableFileStream(ipfsPath, decryptKey);
+          fileSize = fileStream.getSize();
+          if (fileStream) {
+            const match = range.match(/bytes=(\d+)-(\d+)?/);
+            if (match) {
+              start = parseInt(match[1]);
+              end = match[2] ? parseInt(match[2]) : start + DEFAULT_CHUNK_SIZE - 1;
+              if (end >= fileSize) {
+                // 如果请求的结束范围超过文件大小，则调整为文件大小
+                end = fileSize - 1;
+              }
+              logger.info(`处理范围请求: ${start}-${end}, 总大小: ${fileStream.getSize()}`);
+              fileStream.seek(start);
+              fileData = await fileStream.read(end - start + 1);
+              // 如果读取到文件末尾，清理缓存
+              if (end >= fileStream.getSize() - 1) {
+                logger.info(`文件读取完成，清理缓存: ${pathname}`);
+                fileOps.clearFileCache(pathname);
+              }
+            }
+          }
+        } catch (err) {
+          logger.error('文件流操作失败:', err);
+          // 发生错误时清理缓存
+          fileOps.clearFileCache(pathname);
+          port.postMessage({
+            success: false,
+            error: err instanceof Error ? err.message : 'File stream operation failed'
+          });
+          return;
+        }
+      } else {
+        const [fileContent, error] = await fileOps.getFile(ipfsPath, decryptKey);
+        fileData = fileContent;
+        // 普通文件请求
+        fileSize = fileData ? fileData.length : 0;
+        // 非范围请求的文件读取完成后，清理缓存
+        fileOps.clearFileCache(pathname);
+      }
+      if (!fileData) {
+        port.postMessage({
+          success: false,
+          error: 'no data'
+        });
+        return;
+      }
+      if (fileData && fileData.buffer) {
+        // 创建不包含 buffer 的基本响应对象
+        const responseObj = {
+          success: true,
+          status: range ? 206 : 200,
+          headers: {
+            'Content-Range': range ? `bytes ${start}-${end}/${fileSize}` : undefined,
+            'Accept-Ranges': 'bytes',
+            'Cache-Control': 'no-cache',
+            'Content-Length': fileData.length
+          }
+        };
+        // 传递时才添加 data 字段
+        // 注意：在这个方法里 fileData.buffer 被转移后，fileData 将不再可用
+        port.postMessage({
+          ...responseObj,
+          data: fileData.buffer
+        }, [fileData.buffer]);
+        // 手动清除引用
+        fileData = null;
+      } else {
+        port.postMessage({
+          success: false,
+          error: 'Missing data buffer'
+        });
+      }
+    } else {
+      // 文件操作对象不可用
+      port.postMessage({
+        success: false,
+        error: 'File operations not available'
+      });
+    }
+  } catch (error) {
+    logger.error('处理IPFS请求失败:', error);
+    // 全局错误捕获时也清理缓存
+    if (fileOps && pathname) {
+      fileOps.clearFileCache(pathname);
+    }
+    port.postMessage({
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    });
+  }
+}
+/**
+ * 检查Service Worker状态
+ * @returns Promise<boolean> Service Worker是否活跃
+ */
+async function isServiceWorkerActive() {
+  if (!('serviceWorker' in navigator)) {
+    return false;
+  }
+  try {
+    const registration = await navigator.serviceWorker.ready;
+    return !!registration.active;
+  } catch (error) {
+    logger.error('检查Service Worker状态失败:', error);
+    return false;
+  }
+}
+/**
+ * 强制更新Service Worker
+ * @returns Promise<boolean> 是否成功更新
+ */
+async function updateServiceWorker() {
+  if (!('serviceWorker' in navigator)) {
+    return false;
+  }
+  try {
+    const registration = await navigator.serviceWorker.getRegistration();
+    if (registration) {
+      await registration.update();
+      logger.info('Service Worker 已更新');
+      return true;
+    }
+    return false;
+  } catch (error) {
+    logger.error('更新Service Worker失败:', error);
+    return false;
+  }
+}
+
+exports.handleIpfsRequest = handleIpfsRequest;
+exports.isServiceWorkerActive = isServiceWorkerActive;
+exports.registerServiceWorker = registerServiceWorker;
+exports.updateServiceWorker = updateServiceWorker;

package/dist/cjs/common/types/types.js

@@ -0,0 +1,72 @@
+'use strict';
+
+// modelConfig := ModelConfig{
+// 		Model:         "tngtech/deepseek-r1t-chimera:free",
+// 		Temperature:   0.7,
+// 		MaxTokens:     10000,
+// 		TopP:          0.9,
+// 		TopK:          40,
+// 		StopSequences: []string{},
+// 		SystemPrompt:  "你是一个软件开发专家.",
+// 		Stream:        true,
+// 	}
+// 定义AI流式响应状态枚举
+exports.AIStreamResponseFlag = void 0;
+(function (AIStreamResponseFlag) {
+  /** 流式响应进行中 */
+  AIStreamResponseFlag[AIStreamResponseFlag["STREAMING"] = 0] = "STREAMING";
+  /** 推理信息流式响应进行中 */
+  AIStreamResponseFlag[AIStreamResponseFlag["STREAMING_REASON"] = 1] = "STREAMING_REASON";
+  /** 权限不足 */
+  AIStreamResponseFlag[AIStreamResponseFlag["PERMISSION_DENIED"] = 2] = "PERMISSION_DENIED";
+  /** 获取失败 */
+  AIStreamResponseFlag[AIStreamResponseFlag["FETCH_FAILED"] = 3] = "FETCH_FAILED";
+  /** 关闭连接 */
+  AIStreamResponseFlag[AIStreamResponseFlag["CONNECTION_CLOSED"] = 4] = "CONNECTION_CLOSED";
+  /** Token数超限，需要继续请求 */
+  AIStreamResponseFlag[AIStreamResponseFlag["TOKEN_LIMIT_EXCEEDED"] = 5] = "TOKEN_LIMIT_EXCEEDED";
+  AIStreamResponseFlag[AIStreamResponseFlag["TOOLCALL"] = 6] = "TOOLCALL";
+  // 外部退出
+  AIStreamResponseFlag[AIStreamResponseFlag["EXTERNAL_EXIT"] = 7] = "EXTERNAL_EXIT";
+  /** 卡住了 */
+  AIStreamResponseFlag[AIStreamResponseFlag["STREAM_HANG"] = 88] = "STREAM_HANG";
+  /** 其他错误 */
+  AIStreamResponseFlag[AIStreamResponseFlag["OTHER_ERROR"] = 99] = "OTHER_ERROR";
+})(exports.AIStreamResponseFlag || (exports.AIStreamResponseFlag = {}));
+exports.NFTBindStatus = void 0;
+(function (NFTBindStatus) {
+  NFTBindStatus[NFTBindStatus["Success"] = 0] = "Success";
+  NFTBindStatus[NFTBindStatus["UserBinded"] = 1] = "UserBinded";
+  NFTBindStatus[NFTBindStatus["NftAccountBinded"] = 2] = "NftAccountBinded";
+  NFTBindStatus[NFTBindStatus["NoBcAccount"] = 3] = "NoBcAccount";
+  NFTBindStatus[NFTBindStatus["DcPeerNotConnected"] = 4] = "DcPeerNotConnected";
+  NFTBindStatus[NFTBindStatus["EncryptError"] = 5] = "EncryptError";
+  NFTBindStatus[NFTBindStatus["BlockchainError"] = 6] = "BlockchainError";
+  NFTBindStatus[NFTBindStatus["SignError"] = 7] = "SignError";
+  NFTBindStatus[NFTBindStatus["SpaceExpired"] = 8] = "SpaceExpired";
+  NFTBindStatus[NFTBindStatus["NoLeftSpace"] = 9] = "NoLeftSpace";
+  NFTBindStatus[NFTBindStatus["NetworkErr"] = 10] = "NetworkErr";
+  NFTBindStatus[NFTBindStatus["Error"] = 99] = "Error"; // 其他异常
+})(exports.NFTBindStatus || (exports.NFTBindStatus = {}));
+exports.UploadStatus = void 0;
+(function (UploadStatus) {
+  UploadStatus[UploadStatus["OK"] = 0] = "OK";
+  UploadStatus[UploadStatus["ENCRYPTING"] = 1] = "ENCRYPTING";
+  UploadStatus[UploadStatus["UPLOADING"] = 2] = "UPLOADING";
+  UploadStatus[UploadStatus["ERROR"] = 3] = "ERROR";
+  UploadStatus[UploadStatus["ABNORMAL"] = 4] = "ABNORMAL";
+  UploadStatus[UploadStatus["PULLERROR"] = 5] = "PULLERROR";
+  UploadStatus[UploadStatus["FILESIZEERROR"] = 6] = "FILESIZEERROR";
+  UploadStatus[UploadStatus["FILECOUNTERROR"] = 7] = "FILECOUNTERROR";
+  UploadStatus[UploadStatus["NOSPACE"] = 8] = "NOSPACE";
+})(exports.UploadStatus || (exports.UploadStatus = {}));
+exports.PeerStatus = void 0;
+(function (PeerStatus) {
+  PeerStatus[PeerStatus["PeerStatusOffline"] = 1] = "PeerStatusOffline";
+  PeerStatus[PeerStatus["PeerStatusJoining"] = 2] = "PeerStatusJoining";
+  PeerStatus[PeerStatus["PeerStatusOnline"] = 3] = "PeerStatusOnline";
+  PeerStatus[PeerStatus["PeerStatusStaked"] = 4] = "PeerStatusStaked";
+  PeerStatus[PeerStatus["PeerStatusErr"] = 5] = "PeerStatusErr";
+  PeerStatus[PeerStatus["PeerStatusClose"] = 6] = "PeerStatusClose";
+  PeerStatus[PeerStatus["PeerStatusDiscard"] = 7] = "PeerStatusDiscard";
+})(exports.PeerStatus || (exports.PeerStatus = {}));