web-dc-api 0.0.47 → 0.0.49

package/lib/common/chain.ts

@@ -6,7 +6,7 @@ import { Multiaddr, multiaddr } from "@multiformats/multiaddr";
 import { ApiPromise, WsProvider } from "@polkadot/api";
 
 import { isUser, sha256,hexToAscii } from "../util/utils";
-import { IAppInfo, User } from "./types/types";
+import { IAppInfo, User,PeerStatus } from "./types/types";
 
 import { hexToBytes } from "@noble/curves/abstract/utils";
 import { base32 } from "multiformats/bases/base32";
@@ -263,7 +263,7 @@ export class ChainUtil {
   // 链上查询节点webrtc direct的地址信息,
   // peerid: 节点的peerid
   // 直接连接节点的地址
-  getDcNodeWebrtcDirectAddr = async (peerid: string): Promise<Multiaddr | null> => {
+  getDcNodeWebrtcDirectAddr = async (peerid: string): Promise<[Multiaddr | null, PeerStatus]> => {
     const peerInfo = await (this.dcchainapi?.query as any).dcNode.peers(peerid);
     const peerInfoJson = peerInfo?.toJSON();
     if (
@@ -272,7 +272,7 @@ export class ChainUtil {
       (peerInfoJson as { ipAddress: string }).ipAddress == ""
     ) {
       console.error("no ip address found for peer: ", peerid);
-      return null;
+      return [null, PeerStatus.PeerStatusOffline];
     }
     let nodeAddr = Buffer.from(
       (peerInfoJson as { ipAddress: string }).ipAddress.slice(2),
@@ -280,10 +280,11 @@ export class ChainUtil {
     ).toString("utf8");
     let addrParts = nodeAddr.split(",");
     if (addrParts.length < 2) {
-      return null;
+      return [null, PeerStatus.PeerStatusOffline];
     }
     const addr = multiaddr(addrParts[1]);
-    return addr;
+    const peerStatus = (peerInfoJson as { status: number }).status || PeerStatus.PeerStatusOffline;
+    return [addr, peerStatus];
   };
 
   // 链上查询节点列表

package/lib/common/dcutil.ts

@@ -92,7 +92,7 @@ export class DcUtil {
         if (!peerListJson[i]) {
           return;
         }
-        const nodeAddr = await _this.dcChain.getDcNodeWebrtcDirectAddr(
+        const [nodeAddr,_] = await _this.dcChain.getDcNodeWebrtcDirectAddr(
           peerListJson[i]
         );
         if (!nodeAddr) {
@@ -343,16 +343,16 @@ export class DcUtil {
     }
   };
   _getNodeAddr = async (peerId: string): Promise<Multiaddr | undefined> => {
-    let nodeAddr = await this.dcChain.getDcNodeWebrtcDirectAddr(peerId) || undefined;
+    let [nodeAddr, _] = await this.dcChain.getDcNodeWebrtcDirectAddr(peerId);
     if (!nodeAddr) {
       console.error("no node address found for peer: ", peerId);
       return;
     }
     if (isName(nodeAddr)) {
       const addrs = await nodeAddr.resolve();
-      nodeAddr = addrs[0] ;
+      nodeAddr = addrs[0] ? addrs[0] : null;
     }
-    return nodeAddr;
+    return nodeAddr ? nodeAddr : undefined;
   };
 
   getDefaultDcNodeAddr = async (): Promise<Multiaddr | undefined> => {

package/lib/common/define.ts

@@ -21,7 +21,7 @@ const walletOpenVersion =
 
 let _baseUrl = "";
 let _walletOrigin = "";
-if (isProd) {
+if (true) {
     _baseUrl = "/v0_0_10";
     _walletOrigin = "https://wallet.dcnetio.com";
     if(walletOpenType === "iframe") {

package/lib/common/service-worker.ts

@@ -68,7 +68,7 @@ export async function registerServiceWorker(fileOps?: IFileOperations, swUrl: st
  * @param port 消息端口
  * @param fileOps 文件操作对象
  */
-async function handleIpfsRequest(
+export async function handleIpfsRequest(
   data: { id: string, pathname: string, range?: string }, 
   port: MessagePort, 
   fileOps?: IFileOperations

package/lib/common/types/types.ts

@@ -235,6 +235,16 @@ export enum UploadStatus {
   NOSPACE=8, // 存储空间不足
 };
 
+export enum PeerStatus {
+  PeerStatusOffline = 1,
+	PeerStatusJoining = 2, //Joining the network
+	PeerStatusOnline = 3,
+	PeerStatusStaked = 4,
+	PeerStatusErr = 5,
+	PeerStatusClose = 6,
+	PeerStatusDiscard = 7
+}
+
 export type SignReqMessageData = {
     appUrl: string,
     ethAccount: string,

package/lib/dc.ts

@@ -82,7 +82,7 @@ export class DC implements DCContext {
     this.dcChain = new ChainUtil();
     this.dcutil = new DcUtil(this.dcChain);
     // //todo 发布注释 remove
-      //  this.dcutil.defaultPeerId= "12D3KooWEGzh4AcbJrfZMfQb63wncBUpscMEEyiMemSWzEnjVCPf";
+    //  this.dcutil.defaultPeerId= "12D3KooWEGzh4AcbJrfZMfQb63wncBUpscMEEyiMemSWzEnjVCPf";
     // //todo remove end
     this.appInfo = options.appInfo || ({} as APPInfo);
     this.accountInfo = {} as AccountInfo;

package/lib/implements/threaddb/dbmanager.ts

@@ -1516,7 +1516,21 @@ async  create(threadId: string, collectionName: string, jsonInstance: string): P
     // if (jsonInstance.length > 100 * 1024) { // 100 KB
     // throw new Error("instance too big");
     // }
+
+     // 判断instance里面是否有_mod字段,存在则删除
+        try {
+            const instanceObj = JSON.parse(jsonInstance);
+            if (instanceObj && typeof instanceObj === 'object' && '_mod' in instanceObj) {
+                delete instanceObj._mod;
+                jsonInstance = JSON.stringify(instanceObj);
+            }
+        } catch (err) {
+            // JSON解析失败，保持原字符串不变
+            console.warn('Failed to parse instance JSON, keeping original:', err);
+            throw new Error("Invalid instance JSON format");
+        }
     try {
+
     // 解码threaddbID
     const tID = ThreadID.fromString(threadId);
   
@@ -1587,7 +1601,20 @@ async save(threadId: string, collectionName: string, instance: string): Promise<
         // 解码线程ID
         const tID = ThreadID.fromString(threadId);
         
-     
+        // 判断instance里面是否有_mod字段,存在则删除
+        try {
+            const instanceObj = JSON.parse(instance);
+            if (instanceObj && typeof instanceObj === 'object' && '_mod' in instanceObj) {
+                delete instanceObj._mod;
+                instance = JSON.stringify(instanceObj);
+            }
+        } catch (err) {
+            // JSON解析失败，保持原字符串不变
+            console.warn('Failed to parse instance JSON, keeping original:', err);
+            throw new Error("Invalid instance JSON format");
+        }
+
+
         
         // 获取线程数据库
         const threadDB = await this.getDB(tID);

package/lib/implements/threaddb/net/net.ts

@@ -38,6 +38,7 @@ import {CreateEvent} from '../cbor/event';
 import {Errors} from '../core/db';
 import {net as net_pb} from "../pb/net_pb";
 import {PermanentAddrTTL} from "../common/logstore";
+import {PeerStatus} from '../../../common/types/types';
 import {   
   PeerIDConverter,  
   MultiaddrConverter,  
@@ -101,50 +102,58 @@ export class Network implements Net {
     return signature;
   }
 
-  async getClient(peerId: PeerId):Promise<Client>{
-    let cachedFlag = true;
-    const cacheAddr = this.cachePeers[peerId.toString()]; 
-    let peerAddr: TMultiaddr | null = cacheAddr || null;
-    if (!cacheAddr) {
-      cachedFlag = false;
-      peerAddr = await this.dcChain.getDcNodeWebrtcDirectAddr(peerId.toString());
-    }
-   
-    if (!peerAddr) {
-      throw new Error("peerAddr is null");
-    } 
-    if (!this.context.publicKey){
-      throw new Error("publicKey is null");
-    }
+  async getClient(peerId: PeerId):Promise<[Client | null, Error | null]>{
+    try{
+      let cachedFlag = true;
+      const cacheAddr = this.cachePeers[peerId.toString()]; 
+      let peerAddr: TMultiaddr | null = cacheAddr || null;
+      let peerStatus: PeerStatus | null = null;
+      if (!cacheAddr) {
+        cachedFlag = false;
+        [peerAddr, peerStatus] = await this.dcChain.getDcNodeWebrtcDirectAddr(peerId.toString());
+      }
+    
+      if (!peerAddr) {
+        throw new Error("peerAddr is null");
+      } 
+      if (peerStatus !== PeerStatus.PeerStatusOnline) {
+        throw new Error("peerStatus is not online");
+      }
+      if (!this.context.publicKey){
+        throw new Error("publicKey is null");
+      }
 
-    const addr = multiaddr(peerAddr);
-    const client = new Client(this.libp2p,this.bstore,addr, dc_protocol);
-    //获取token
-    const token = await client.GetToken(this.context.appInfo.appId||"", this.context.publicKey.string(),(payload: Uint8Array):Promise<Uint8Array> => {
-      return this.sign(payload);
-    });
-    if (!token) {
-      if (cachedFlag) {
-        peerAddr = await this.dcChain.getDcNodeWebrtcDirectAddr(peerId.toString());
-        delete this.cachePeers[peerId.toString()];
-        if (!peerAddr) {
-          throw new Error("peerAddr is null");
-        } 
-        const addr = multiaddr(peerAddr);
-        const client = new Client(this.libp2p,this.bstore,addr, dc_protocol);
-        const token = await client.GetToken(this.context.appInfo.appId||"",this.context.publicKey.string(),(payload: Uint8Array) => {
-          return this.sign(payload);
-        });
-        if (token) {
-          this.cachePeers[peerId.toString()] = peerAddr;
-          return client;
+      const addr = multiaddr(peerAddr);
+      const client = new Client(this.libp2p,this.bstore,addr, dc_protocol);
+      //获取token
+      const token = await client.GetToken(this.context.appInfo.appId||"", this.context.publicKey.string(),(payload: Uint8Array):Promise<Uint8Array> => {
+        return this.sign(payload);
+      });
+      if (!token) {
+        if (cachedFlag) {
+          [peerAddr,_] = await this.dcChain.getDcNodeWebrtcDirectAddr(peerId.toString());
+          delete this.cachePeers[peerId.toString()];
+          if (!peerAddr) {
+            throw new Error("peerAddr is null");
+          } 
+          const addr = multiaddr(peerAddr);
+          const client = new Client(this.libp2p,this.bstore,addr, dc_protocol);
+          const token = await client.GetToken(this.context.appInfo.appId||"",this.context.publicKey.string(),(payload: Uint8Array) => {
+            return this.sign(payload);
+          });
+          if (token) {
+            this.cachePeers[peerId.toString()] = peerAddr;
+            return [client, null];
+          }
         }
+        throw new Error("get token is null");
+        
       }
-      throw new Error("get token is null");
-      
+      this.cachePeers[peerId.toString()] = peerAddr;
+      return [client, null];
+    }catch(err){
+      return [null,err as Error];
     }
-    this.cachePeers[peerId.toString()] = peerAddr;
-    return client;
   }
 
   
@@ -315,7 +324,7 @@ async getThreadFromPeer(
   options: { token?: ThreadToken } = {}
 ): Promise<ThreadInfo> {
   try {
-    const client = await this.getClient(peerId);
+    const [client, _] = await this.getClient(peerId);
     if (!client) {
       throw new Error("Failed to get client");
     }
@@ -484,10 +493,14 @@ async ensureUniqueLog(id: ThreadID, key?: Ed25519PrivKey | Ed25519PubKey, identi
    */
   async pullThread(id: ThreadID): Promise<void> {
     try {
+      let recs: Record<string, PeerRecords> = {};
       const mutex = this.getMutexForThread(id.toString());
       await mutex.acquire();
-      const recs = await this.pullThreadDeal(id);
-      mutex.release();
+      try {
+        recs = await this.pullThreadDeal(id);
+      } finally {
+        mutex.release();
+      }
       
       const [connector, appConnected] =  this.getConnector(id);
       
@@ -719,7 +732,7 @@ async ensureUniqueLog(id: ThreadID, key?: Ed25519PrivKey | Ed25519PubKey, identi
 
 async updateLogsFromPeer(tid: ThreadID,peerId: PeerId): Promise<void> {
   try {
-    const client = await this.getClient(peerId);
+    const [client,_] = await this.getClient(peerId);
     if (!client) {
       return ;
     }
@@ -804,7 +817,7 @@ async getRecordsFromPeer(
 ): Promise<Record<string, PeerRecords>> {
   try {
 
-    const client = await this.getClient(peerId);
+    const [client,_] = await this.getClient(peerId);
     if (!client) {
       return {};
     }
@@ -1147,67 +1160,113 @@ async getRecord( id: ThreadID, rid: CID): Promise<IRecord> {
       const recordCollector = new RecordCollector();
       
       // 确定需要获取的对等点数量
-      const needFetched = Math.min(2, peers.length);
-      let fetchedPeers = 0;
+      const needFetched = Math.min(1, peers.length);
+      let resolved = false; // 防止重复调用 resolve
+      // 使用对象来保证引用一致性
+      const fetchState = {
+        fetchedPeers: 0
+      };
+      let mainTimeoutId: NodeJS.Timeout | undefined;
+       // 设置主超时
+      const timeoutPromise = new Promise<void>((resolve) => {
+        mainTimeoutId = setTimeout(() => {
+          resolve(); // 超时时总是resolve，在外部判断是否有足够的数据
+        }, 30000);
+      });
       
       // 创建一个 Promise 在足够的对等点响应时解析
       const fetchPromise = new Promise<void>((resolve) => {
-        // 当所有查询完成时，解析 Promise
+        // 立即检查是否满足条件
         const checkComplete = () => {
-          if (fetchedPeers >= needFetched) {
+          if (!resolved && fetchState.fetchedPeers >= needFetched) {
+            resolved = true;
             resolve();
           }
         };
         
         // 从每个对等点查询记录
         const fetchPromises = peers.map(async (peerId) => {
+          let timeoutId: NodeJS.Timeout | undefined;
+          // 为每个peer设置独立的超时
+          const peerTimeout = new Promise<never>((_, reject) => {
+            timeoutId = setTimeout(() => reject(new Error(`Peer ${peerId} timeout after 30s`)), 30000);
+          });
+          
           try {
-            //连接到指定peerId,返回一个Client
-            const client = await this.getClient(peerId);
-            if (!client) {
-              return;
-            }
-            const dbClient = new DBClient(client,this.dc,this,this.logstore);
-        
-            // 这里使用一个队列来控制并发，类似于 Go 代码中的 queueGetRecords
-            const records = await dbClient.getRecordsFromPeer( req, serviceKey);
-            
-            // 更新收集器
-            Object.entries(records).forEach(([logId, rs]) => {
-              recordCollector.updateHeadCounter(logId, rs.counter);
-              rs.records.forEach(record => {
-                recordCollector.store(logId, record);
-              });
-            });
-            
-            fetchedPeers++;
+            // 使用 Promise.race 为每个peer设置超时
+            await Promise.race([
+              (async () => {
+                //连接到指定peerId,返回一个Client
+                const [client,_] = await this.getClient(peerId);
+                if (!client) {
+                  return;
+                }
+                const dbClient = new DBClient(client,this.dc,this,this.logstore);
             
-            // 如果获取了记录并且达到了所需的对等点数量，则解析 Promise
-            if (Object.keys(records).length > 0 && fetchedPeers >= needFetched) {
-              resolve();
-            }
-            
-            // 暂停一秒钟避免过多并发请求
-            await new Promise(r => setTimeout(r, 1000));
+                const records = await dbClient.getRecordsFromPeer( req, serviceKey);
+                
+                // 更新收集器
+                Object.entries(records).forEach(([logId, rs]) => {
+                  recordCollector.updateHeadCounter(logId, rs.counter);
+                  rs.records.forEach(record => {
+                    recordCollector.store(logId, record);
+                  });
+                });
+                
+                fetchState.fetchedPeers++;
+                
+                // 每次成功获取记录后立即检查是否满足条件
+                checkComplete();
+              })(),
+              peerTimeout
+            ]);
           } catch (err) {
             console.error(`Error getting records from peer ${peerId}:`, err);
+            // 错误不影响其他peer的执行
+          } finally {
+            // 清除定时器，防止内存泄漏
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+            }
+          }
+        });
+        
+        // 使用 Promise.allSettled 替代 Promise.all，避免被单个失败阻塞
+        // 同时设置额外的兜底检查机制
+        Promise.allSettled(fetchPromises).then(() => {
+          if (!resolved) {
+            checkComplete();
           }
         });
         
-        // 当所有查询完成或失败时，检查是否需要解析 Promise
-        Promise.all(fetchPromises.map(p => p.catch(e => e)))
-          .then(() => checkComplete());
+        // 添加定期检查机制，防止被某些未知问题阻塞
+        const checkInterval = setInterval(() => {
+          if (resolved) {
+            clearInterval(checkInterval);
+          } else {
+            checkComplete();
+          }
+        }, 5000); // 每5秒检查一次
+        
+        // 确保interval最终被清理
+        setTimeout(() => clearInterval(checkInterval), 35000);
       });
       
-      // 设置超时
-      const timeoutPromise = new Promise<void>((_, reject) => {
-        setTimeout(() => reject(new Error("Fetch records timeout")), 30000);
-      });
+     
       
       // 等待获取足够的记录或超时
       await Promise.race([fetchPromise, timeoutPromise]);
+       // 清除超时定时器
+      if (mainTimeoutId) {
+        clearTimeout(mainTimeoutId);
+      }
+      // 检查是否获取到足够的数据
+      if (fetchState.fetchedPeers === 0) {
+        throw new Error("Fetch records timeout: no peers responded");
+      }
       
-      // 返回收集到的记录
+      // 如果有数据就返回（不管是1个还是2个节点）
+      console.log(`获取记录完成: ${fetchState.fetchedPeers}/${needFetched} 个节点响应`);
       return recordCollector.list();
     } catch (err) {
       console.error("getRecords error:", err);
@@ -1588,7 +1647,7 @@ async pushRecord(tid: ThreadID, lid: PeerId, rec: IRecord, counter: number): Pro
         continue;
       }
       try {
-         const client  = await this.getClient(p);
+         const [client,_]  = await this.getClient(p);
           if (!client) {
             continue
           }
@@ -1649,7 +1708,7 @@ async exchange(tid: ThreadID): Promise<void> {
 private async exchangeWithPeer(pid: PeerId, tid: ThreadID): Promise<void> {
   try {
     // 获取客户端连接
-    const client = await this.getClient(pid);
+    const [client,_] = await this.getClient(pid);
     if (!client) {
       return;
     }

package/lib/interfaces/util-interface.ts

@@ -1,5 +1,6 @@
 import { IAppInfo } from '../../lib/common/types/types';
 import { SymmetricKey, Key as ThreadKey } from '../implements/threaddb/common/key';
+import { IFileOperations } from './file-interface';
 
 
 export interface IUtilOperations {
@@ -15,4 +16,16 @@ export interface IUtilOperations {
      */
     setAppInfo(appId: string,fid:string,domain:string,owner?: string,rewarder?: string): Promise<[boolean|null, Error | null]>;
     getAppInfo(appId: string): Promise<[IAppInfo|null, Error | null]>;
+
+    /**
+     * 处理IPFS请求
+     * @param data 请求数据
+     * @param port 消息端口
+     * @param fileOps 文件操作对象
+     */
+     handleIpfsRequest(
+      data: { id: string, pathname: string, range?: string }, 
+      port: MessagePort, 
+      fileOps?: IFileOperations
+    ): Promise<void>
 }

package/lib/modules/util-module.ts

@@ -2,11 +2,12 @@
 import { IUtilOperations } from '../interfaces/util-interface';
 import { SymmetricKey,Key as  ThreadKey } from '../implements/threaddb/common/key';
 import { CoreModuleName } from '../common/module-system';
-import { DCContext } from '../interfaces';
+import { DCContext, IFileOperations } from '../interfaces';
 import { createLogger } from '../util/logger';
 import { UtilManager } from '../../lib/implements/util/manager';
 import { IAppInfo } from '../../lib/common/types/types';
 import { Errors } from '../../lib/common/error';
+import { handleIpfsRequest } from '../common/service-worker';
 const logger = createLogger("UtilModule");
 export class UtilModule implements IUtilOperations {
     readonly moduleName = CoreModuleName.UTIL;
@@ -121,5 +122,27 @@ export class UtilModule implements IUtilOperations {
   async shutdown(): Promise<void> {
     this.initialized = false;
   }
+
+
+   /**
+       * 处理IPFS请求
+       * @param data 请求数据
+       * @param port 消息端口
+       * @param fileOps 文件操作对象
+       */
+  async handleIpfsRequest(
+        data: { id: string, pathname: string, range?: string }, 
+        port: MessagePort, 
+        fileOps?: IFileOperations
+      ): Promise<void>{
+        if (!this.initialized) {
+          return;
+        }
+        try {
+          await handleIpfsRequest(data, port, fileOps);
+        } catch (error) {
+          logger.error("页面处理IPFS请求失败:", error);
+        }
+      }
   
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "web-dc-api",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "description": "web相关的dcapi",
   "type": "module",
   "browser": "dist/dc.min.js",
-  "main": "./dist/index.cjs.js",
-  "module": "./dist/index.esm.js",
-  "types": "./dist/index.d.ts",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -52,14 +52,10 @@
     "ajv": "^8.17.1",
     "async-mutex": "^0.5.0",
     "blockstore-idb": "^2.0.1",
-    "cbor-x": "^1.6.0",
     "cids": "^1.1.9",
-    "crypto-js": "^4.2.0",
     "datastore-idb": "^3.0.1",
     "datastore-level": "^11.0.1",
-    "ethers": "^6.14.1",
     "google-protobuf": "~3.21.2",
-    "grpc-libp2p-client": "^0.0.10",
     "helia": "5.3.0",
     "interface-ipld-format": "^1.0.1",
     "it-to-buffer": "^4.0.7",
@@ -68,9 +64,7 @@
     "jscrypto": "^1.0.3",
     "jwt-decode": "^4.0.0",
     "libp2p": "^2.8.1",
-    "lodash": "~4.17.0",
     "lru-cache": "^11.1.0",
-    "mp4box": "^0.5.4",
     "multiaddr": "^10.0.1",
     "multiformats": "^13.3.2",
     "protobufjs": "^7.5.0",
@@ -82,6 +76,12 @@
     "lib": "lib"
   },
   "devDependencies": {
+    "grpc-libp2p-client": "^0.0.10",
+    "cbor-x": "^1.6.0",
+    "crypto-js": "^4.2.0",
+    "ethers": "^6.14.1",
+    "lodash": "~4.17.0",
+    "mp4box": "^0.5.4",
     "@babel/core": "^7.27.4",
     "@babel/preset-env": "^7.27.2",
     "@rollup/plugin-babel": "^6.0.4",
@@ -97,6 +97,8 @@
     "nodemon": "^3.1.9",
     "rollup-plugin-dts": "^6.2.1",
     "typescript": "^5.8.3",
-    "webpack-bundle-analyzer": "^4.10.2"
+    "webpack-bundle-analyzer": "^4.10.2",
+    "vite": "^7.1.2",
+    "vite-plugin-dts": "^4.5.4"
   }
 }