web-dc-api 0.0.46 → 0.0.48

package/lib/common/chain.ts

@@ -52,7 +52,7 @@ export class ChainUtil {
   // 获取用户钱包信息
   async getUserInfoWithAccount(account: string): Promise<User> {
     const walletAccountStorage =
-      await this.dcchainapi?.query.dcNode.walletAccountStorage(account);
+      await (this.dcchainapi?.query as any).dcNode.walletAccountStorage(account);
     if (!walletAccountStorage) {
       throw new Error("walletAccountStorage is null");
     }
@@ -67,7 +67,7 @@ export class ChainUtil {
     }
     if (userInfo?.parentAccount !== account) {
       const parentWalletAccountStorage =
-        await this.dcchainapi?.query.dcNode.walletAccountStorage(
+        await (this.dcchainapi?.query as any).dcNode.walletAccountStorage(
           userInfo?.parentAccount
         );
       if (!parentWalletAccountStorage) {
@@ -131,7 +131,7 @@ export class ChainUtil {
   // 获取用户钱包信息
   async getUserInfoWithNftHex(nftHexAccount: string): Promise<User> {
     const walletAccount =
-      await this.dcchainapi?.query.dcNode.nftToWalletAccount(nftHexAccount);
+      await (this.dcchainapi?.query as any).dcNode.nftToWalletAccount(nftHexAccount);
     if (!walletAccount || !walletAccount.toString()) {
       throw new Error("walletAccount is null");
     }
@@ -191,7 +191,7 @@ export class ChainUtil {
     const accountHash = await sha256(accountBytes);
     const nftHexAccount = "0x" + Buffer.from(accountHash).toString("hex");
     const walletAccount =
-      await this.dcchainapi?.query.dcNode.nftToWalletAccount(nftHexAccount);
+      await (this.dcchainapi?.query as any).dcNode.nftToWalletAccount(nftHexAccount);
     if (!walletAccount || !walletAccount.toString()) {
       throw new Error("walletAccount is null");
     }
@@ -200,7 +200,7 @@ export class ChainUtil {
 
   // 获取所有文件存储节点
   getObjNodes = async (cid: string): Promise<string[] | undefined> => {
-    const fileInfo = (await this.dcchainapi?.query.dcNode.files(cid)) || null;
+    const fileInfo = (await (this.dcchainapi?.query as any).dcNode.files(cid)) || null;
     const fileInfoJSON = fileInfo?.toJSON();
     if (
       !fileInfoJSON ||
@@ -226,7 +226,7 @@ export class ChainUtil {
 
   // 链上查询节点信息
   // getDcNodeAddr = async (peerid: string) => {
-  //   const peerInfo = await this.dcchainapi?.query.dcNode.peers(peerid);
+  //   const peerInfo = await (this.dcchainapi?.query as any).dcNode.peers(peerid);
   //   const peerInfoJson = peerInfo?.toJSON();
   //   if (
   //     !peerInfoJson ||
@@ -264,7 +264,7 @@ export class ChainUtil {
   // peerid: 节点的peerid
   // 直接连接节点的地址
   getDcNodeWebrtcDirectAddr = async (peerid: string): Promise<Multiaddr | null> => {
-    const peerInfo = await this.dcchainapi?.query.dcNode.peers(peerid);
+    const peerInfo = await (this.dcchainapi?.query as any).dcNode.peers(peerid);
     const peerInfoJson = peerInfo?.toJSON();
     if (
       !peerInfoJson ||
@@ -288,7 +288,7 @@ export class ChainUtil {
 
   // 链上查询节点列表
   getDcNodeList = async (): Promise<string[]> => {
-    const peerList = await this.dcchainapi?.query.dcNode.onlineNodesAddress();
+    const peerList = await (this.dcchainapi?.query as any).dcNode.onlineNodesAddress();
     const peerListJson = peerList?.toJSON();
     console.log(
       "peerListJson================================================",
@@ -319,7 +319,7 @@ export class ChainUtil {
           return [null, new Error("dcchainapi is not initialized")];
       }  
 
-      const fileInfo = await this.dcchainapi.query.dcNode.files(cid);  
+      const fileInfo = await (this.dcchainapi.query as any).dcNode.files(cid);  
       
       if (!fileInfo || fileInfo.isEmpty) {  
           return [null, new Error(`File with CID ${cid} not found`)];  
@@ -426,7 +426,7 @@ export class ChainUtil {
     }
     const appIdBytes = new TextEncoder().encode(appId);
     const appIdHex = "0x" + Buffer.from(appIdBytes).toString("hex");
-    const appInfoStr = await this.dcchainapi?.query.dcNode.appsInfo(appIdHex);
+    const appInfoStr = await (this.dcchainapi?.query as any).dcNode.appsInfo(appIdHex);
     if (!appInfoStr || appInfoStr.isEmpty) {
       throw new Error(`App info for ${appId} not found`);
     }

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

@@ -28,13 +28,30 @@ export async function registerServiceWorker(fileOps?: IFileOperations, swUrl: st
       : '/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) {
@@ -51,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/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/account/manager.ts

@@ -413,7 +413,7 @@ export class AccountManager {
       const accountHash = await sha256(accountBytes);
       const nftHexAccount = "0x" + Buffer.from(accountHash).toString("hex");
       const walletAccount =
-        await this.chainUtil.dcchainapi?.query.dcNode.nftToWalletAccount(
+        await (this.chainUtil.dcchainapi?.query as any).dcNode.nftToWalletAccount(
           nftHexAccount
         );
       // 比较公钥
@@ -441,7 +441,7 @@ export class AccountManager {
       const accountHash = await sha256(accountBytes);
       const nftHexAccount = "0x" + Buffer.from(accountHash).toString("hex");
       const walletAccount =
-        await this.chainUtil.dcchainapi?.query.dcNode.nftToWalletAccount(
+        await (this.chainUtil.dcchainapi?.query as any).dcNode.nftToWalletAccount(
           nftHexAccount
         );
       if (!walletAccount.toString()) {

package/lib/implements/comment/client.ts

@@ -94,7 +94,59 @@ export class CommentClient {
   }
 
 
-  
+  async getUserOffChainUsedInfo(
+    vaccount: string = ""
+  ): Promise<dcnet.pb.GetUserOffChainUsedInfoReply> {
+    const message = new dcnet.pb.GetUserOffChainUsedInfoRequest({});
+    message.vaccount = new TextEncoder().encode(vaccount);
+    const messageBytes =
+      dcnet.pb.GetUserOffChainUsedInfoRequest.encode(message).finish();
+    try {
+      const grpcClient = new Libp2pGrpcClient(
+        this.client.p2pNode,
+        this.client.peerAddr,
+        this.client.token,
+        this.client.protocol
+      );
+      const reply = await grpcClient.unaryCall(
+        "/dcnet.pb.Service/GetUserOffChainUsedInfo",
+        messageBytes,
+        30000
+      );
+      const decoded = dcnet.pb.GetUserOffChainUsedInfoReply.decode(reply);
+      return decoded;
+    } catch (error: any) {
+        if (error.message.indexOf(Errors.INVALID_TOKEN.message) != -1) {
+          // try to get token
+          const token = await this.client.GetToken(
+            this.context.appInfo.appId || "",
+            this.context.getPublicKey().string(),
+            (payload: Uint8Array): Promise<Uint8Array> => {
+              return this.context.sign(payload);
+            }
+          );
+          if (!token) {
+            throw new Error(Errors.INVALID_TOKEN.message);
+          }
+          const grpcClient = new Libp2pGrpcClient(
+            this.client.p2pNode,
+            this.client.peerAddr,
+            this.client.token,
+            this.client.protocol
+          );
+          const reply = await grpcClient.unaryCall(
+            "/dcnet.pb.Service/GetUserOffChainUsedInfo",
+            messageBytes,
+            30000
+          );
+          const decoded = dcnet.pb.GetUserOffChainUsedInfoReply.decode(reply);
+          console.log("GetUserOffChainUsedInfo decoded", decoded);
+          return decoded;
+        }
+        throw error;
+      }
+    
+  }
 
   async addUserOffChainOpTimes(
     pubkey: string,

package/lib/implements/comment/manager.ts

@@ -310,7 +310,25 @@ export class CommentManager {
     }
   }
 
-
+async getUserOffChainUsedInfo(vaccount: string = ""): Promise<[dcnet.pb.GetUserOffChainUsedInfoReply | null, Error | null]> {
+  try {
+    if (!this.accountBackupDc?.client) {
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    if(!this.accountBackupDc?.nodeAddr){
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    const commentClient = new CommentClient(
+      this.accountBackupDc.client,
+      this.dcNodeClient,
+      this.context
+    );
+    const res = await commentClient.getUserOffChainUsedInfo(vaccount);
+    return [res, null];
+  } catch (err) {
+    return [null, err as Error];
+  }
+}
 
 async addUserOffChainOpTimes(
   times: number,

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

@@ -484,10 +484,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);
       
@@ -1148,66 +1152,113 @@ async getRecord( id: ThreadID, rid: CID): Promise<IRecord> {
       
       // 确定需要获取的对等点数量
       const needFetched = Math.min(2, peers.length);
-      let fetchedPeers = 0;
+      let resolved = false; // 防止重复调用 resolve
+      // 使用对象来保证引用一致性
+      const fetchState = {
+        fetchedPeers: 0
+      };
+      let timeoutId: NodeJS.Timeout | undefined;
+       // 设置超时
+      const timeoutPromise = new Promise<void>((resolve) => {
+        timeoutId = 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
-            if (Object.keys(records).length > 0 && fetchedPeers >= needFetched) {
-              resolve();
-            }
+            // 使用 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);
             
-            // 暂停一秒钟避免过多并发请求
-            await new Promise(r => setTimeout(r, 1000));
+                // 这里使用一个队列来控制并发，类似于 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);
+                  });
+                });
+                
+                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 (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      // 检查是否获取到足够的数据
+      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);

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 {
@@ -8,11 +9,23 @@ export interface IUtilOperations {
     /**
      * 设置应用信息,发布应用时调用  
      * @param appId string 应用ID
-     * @param domain 
      * @param fid 
+     * @param domain 
      * @param owner 
      * @param rewarder 
      */
-    setAppInfo(appId: string,domain:string,fid:string,owner?: string,rewarder?: string): Promise<[boolean|null, Error | null]>;
+    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/auth-module.ts

@@ -115,21 +115,26 @@ export class AuthModule implements DCModule, IAuthOperations {
       if (userInfo == null) {
         throw Errors.USER_NOT_BIND_TO_PEER;
       }
-      if (
-        userInfo.offchainSpace < OffChainSpaceLimit ||
-        userInfo.offchainOptimes < OffChainOpTimesLimit
-      ) {
-        const commentManager = new CommentManager(this.context);
-        if (userInfo.offchainSpace < OffChainSpaceLimit) {
-          const [addOffChainBool, addOffChainError] =
-            await commentManager.addUserOffChainSpace();
+      //获取用户已经使用的评论空间和操作次数
+      const commentManager = new CommentManager(this.context);
+      const [offchainUsedInfo,resErr] = await commentManager.getUserOffChainUsedInfo()
+      if (resErr) {
+        throw resErr;
+      }
+      const leftSpace = offchainUsedInfo?userInfo.offchainSpace - Number(offchainUsedInfo.usedspace) :userInfo.offchainSpace;
+      const leftOptimes = offchainUsedInfo?userInfo.offchainOptimes - Number(offchainUsedInfo.usedtimes):userInfo.offchainOptimes;
+      logger.info(
+        `用户线下评论空间剩余: ${leftSpace} / ${userInfo.offchainSpace}, 线下操作次数剩余: ${leftOptimes} / ${userInfo.offchainOptimes}`
+      );
+      if (leftSpace < OffChainSpaceLimit || leftOptimes < OffChainOpTimesLimit) {
+        if (leftSpace < OffChainSpaceLimit) {
+          const [addOffChainBool, addOffChainError] = await commentManager.addUserOffChainSpace();
           if (addOffChainError || !addOffChainBool) {
             throw addOffChainError || new Error("addUserOffChainSpace error");
           }
         }
-        if (userInfo.offchainOptimes < OffChainOpTimesLimit) {
-          const [addOffChainOpTimesBool, addOffChainOpTimesError] =
-            await commentManager.addUserOffChainOpTimes(OffChainOpTimes);
+        if (leftOptimes < OffChainOpTimesLimit) {
+          const [addOffChainOpTimesBool, addOffChainOpTimesError] =await commentManager.addUserOffChainOpTimes(OffChainOpTimes);
           if (addOffChainOpTimesError || !addOffChainOpTimesBool) {
             throw (
               addOffChainOpTimesError || new Error("addUserOffChainSpace error")

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,6 +1,6 @@
 {
   "name": "web-dc-api",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "web相关的dcapi",
   "type": "module",
   "browser": "dist/dc.min.js",