web-dc-api 0.1.2 → 0.1.3

package/dist/index.d.ts

@@ -2904,7 +2904,7 @@ interface AddrBook {
     clearAddrs(threadId: ThreadID, peerId: PeerId): Promise<void>;
     logsWithAddrs(threadId: ThreadID): Promise<PeerId[]>;
     threadsFromAddrs(): Promise<ThreadID[]>;
-    addrsEdge(threadId: ThreadID): Promise<number>;
+    addrsEdge(threadId: ThreadID, exceptPeerId?: string): Promise<bigint>;
     dumpAddrs(): Promise<DumpAddrBook>;
     restoreAddrs(book: DumpAddrBook): Promise<void>;
 }
@@ -2915,7 +2915,7 @@ interface HeadBook {
     setHeads(threadId: ThreadID, peerId: PeerId, heads: Head[]): Promise<void>;
     heads(threadId: ThreadID, peerId: PeerId): Promise<Head[]>;
     clearHeads(threadId: ThreadID, peerId: PeerId): Promise<void>;
-    headsEdge(threadId: ThreadID): Promise<number>;
+    headsEdge(threadId: ThreadID): Promise<bigint>;
     dumpHeads(): Promise<DumpHeadBook>;
     restoreHeads(book: DumpHeadBook): Promise<void>;
 }
@@ -2995,6 +2995,7 @@ declare class DBClient {
      * @throws 错误，包括特定的"No address edge"和"No heads edge"错误
      */
     private localEdges;
+    private edgeToBigInt;
     /**
      * 调度日志更新
      * @param tid threaddb ID

package/lib/common/define.ts

@@ -23,7 +23,7 @@ const walletOpenVersion =
 let _baseUrl = "";
 let _walletOrigin = "";
 if (true) {
-  _baseUrl = "/v0_0_18";
+  _baseUrl = "/v0_0_19";
   _walletOrigin = "https://wallet.dcnetio.com";
 
   if (walletOpenOrgin) {

package/lib/implements/threaddb/common/logstore.ts

@@ -11,7 +11,7 @@ import {Key as ThreadKey} from './key';
 import {ThreadInfo} from '../core/core';
 import {Errors} from '../core/db';
 
-export const PermanentAddrTTL = 2^53-1; // 使用 bigint 精确表示 64 位整数  
+export const PermanentAddrTTL = 2**53-1; 
 
 
 const managedSuffix = "/managed";

package/lib/implements/threaddb/core/logstore.ts

@@ -63,7 +63,7 @@ export interface AddrBook {
   clearAddrs(threadId: ThreadID, peerId: PeerId): Promise<void>;  
   logsWithAddrs(threadId: ThreadID): Promise<PeerId[]>;  
   threadsFromAddrs(): Promise<ThreadID[]>;  
-  addrsEdge(threadId: ThreadID): Promise<number>;  
+  addrsEdge(threadId: ThreadID,exceptPeerId?:string): Promise<bigint>;  
   dumpAddrs(): Promise<DumpAddrBook>;  
   restoreAddrs(book: DumpAddrBook): Promise<void>;  
 }  
@@ -75,7 +75,7 @@ export interface HeadBook {
   setHeads(threadId: ThreadID, peerId: PeerId, heads: Head[]): Promise<void>;  
   heads(threadId: ThreadID, peerId: PeerId): Promise<Head[]>;  
   clearHeads(threadId: ThreadID, peerId: PeerId): Promise<void>;  
-  headsEdge(threadId: ThreadID): Promise<number>;  
+  headsEdge(threadId: ThreadID): Promise<bigint>;  
   dumpHeads(): Promise<DumpHeadBook>;  
   restoreHeads(book: DumpHeadBook): Promise<void>;  
 }  

package/lib/implements/threaddb/dbclient.ts

@@ -1,5 +1,6 @@
 import type { Client } from "../../common/dcapi";
 import type { Multiaddr as TMultiaddr } from "@multiformats/multiaddr";
+import Long from "long";
 import { extractPublicKeyFromPeerId } from "../../common/dc-key/keyManager";
 import { SymmetricKey} from './common/key';
 import { NewThreadOptions } from './core/options';
@@ -188,8 +189,8 @@ async exchangeEdges(threadIds: ThreadID[]): Promise<void> {
         // 添加到请求中
         body.threads.push({
           threadID: tid.toBytes(),
-          headsEdge: headsEdge,
-          addressEdge: addrEdge
+          headsEdge: Long.fromString(headsEdge.toString(), true),
+          addressEdge: Long.fromString(addrEdge.toString(), true)
         });
       } catch (err:any) {
         if (err.message !== "No address edge" && 
@@ -238,8 +239,8 @@ async exchangeEdges(threadIds: ThreadID[]): Promise<void> {
         let addrEdgeLocal = 0, headsEdgeLocal = 0;
         try {
           const localEdges = await this.localEdges(tid);
-          addrEdgeLocal = localEdges.addrEdge;
-          headsEdgeLocal = localEdges.headsEdge;
+          addrEdgeLocal = Number(localEdges.addrEdge)||0;
+          headsEdgeLocal = Number(localEdges.headsEdge)||0;
         } catch (err:any) {
           // 允许本地边缘为空
           if (err.message !== "No address edge" && 
@@ -250,7 +251,7 @@ async exchangeEdges(threadIds: ThreadID[]): Promise<void> {
         }
         let needPush = false;
         // 检查地址边缘是否有更新
-        const responseAddrEdge = edge.addressEdge || 0;
+        const responseAddrEdge = Number(edge.addressEdge ) || 0;
         if (responseAddrEdge !== 0 && responseAddrEdge !== addrEdgeLocal) {
           // 调度日志更新
           await this.scheduleUpdateLogs(tid);
@@ -258,7 +259,7 @@ async exchangeEdges(threadIds: ThreadID[]): Promise<void> {
           console.debug(`Log information update for thread ${tid} scheduled`);
         }
         // 检查头部边缘是否有更新
-        const responseHeadEdge = edge.headsEdge || 0;
+        const responseHeadEdge = Number(edge.headsEdge) || 0;
         if (responseHeadEdge !== 0 && responseHeadEdge !== headsEdgeLocal) {
           // 调度记录更新
           await this.scheduleUpdateRecords(tid);
@@ -331,14 +332,23 @@ private async pushLogsHeadToPeer(tid: ThreadID): Promise<void> {
  * @returns 地址边缘值和头部边缘值的对象
  * @throws 错误，包括特定的"No address edge"和"No heads edge"错误
  */
-private async localEdges(tid: ThreadID): Promise<{ addrEdge: number, headsEdge: number }> {
+private async localEdges(tid: ThreadID): Promise<{ addrEdge: bigint, headsEdge: bigint }> {
   // 使用默认值初始化头部边缘值
-  let headsEdge = 0; // EmptyEdgeValue 在 TS 中对应于 0
-  let addrEdge = 0;
+  let headsEdge = 0n; // EmptyEdgeValue 对应 0n
+  let addrEdge = 0n;
 
   try {
-    // 尝试获取地址边缘值
-    addrEdge = await this.logstore.addrBook.addrsEdge(tid);
+     const exceptLogId = await this.logstore.metadata.getString(
+        tid,
+        "local_log_no_record_flag"
+      );
+       // 尝试获取地址边缘值
+      if (exceptLogId && exceptLogId?.length > 0) {
+        addrEdge = await this.logstore.addrBook.addrsEdge(tid,exceptLogId);
+      }else{
+        addrEdge = await this.logstore.addrBook.addrsEdge(tid);
+      }
+   
   } catch (err:any) {
     // // 处理threaddb 未找到错误
     // if (err.message.includes("Thread not found")) {
@@ -363,6 +373,19 @@ private async localEdges(tid: ThreadID): Promise<{ addrEdge: number, headsEdge:
   // 返回边缘值对象
   return { addrEdge, headsEdge };
 }
+
+private edgeToBigInt(value: number | Long | undefined | null): bigint {
+  if (value == null) {
+    return 0n;
+  }
+  if (typeof value === "number") {
+    return BigInt(value >>> 0);
+  }
+  if (Long.isLong(value)) {
+    return BigInt(value.toString());
+  }
+  return 0n;
+}
 /**
  * 调度日志更新
  * @param tid threaddb ID

package/lib/implements/threaddb/lsstoreds/addr_book.ts

@@ -8,7 +8,11 @@ import  * as pb from '../pb/lstore'
 import {uniqueLogIds,uniqueThreadIds,DSOptions,AllowEmptyRestore,dsThreadKey} from './global'
 import {LRUCache} from 'lru-cache'  
 import { ThreadID } from '@textile/threads-id';
-import {DefaultOpts} from './global'
+import {DefaultOpts} from './global';
+import { TxnDatastoreExtended, Transaction } from '../core/db';
+import * as buffer from "buffer/";
+import { bases } from 'multiformats/basics';
+const { Buffer } = buffer;
 
 const ADDR_FNV_OFFSET_BASIS = 0xcbf29ce484222325n;
 const ADDR_FNV_PRIME = 0x100000001b3n;
@@ -61,12 +65,12 @@ export class DsAddrBook implements AddrBook {
  
  
   private opts: DSOptions  
-  private ds: Datastore  
+  private ds: TxnDatastoreExtended  
    cache: LRUCache<CacheKey, AddrsRecord>  
 
   constructor( ds: Datastore, opts: DSOptions) {  
     this.opts = opts  
-    this.ds = ds  
+    this.ds = ds as TxnDatastoreExtended  
     this.cache = new LRUCache({ max: opts.CacheSize || 0 })   
   }  
 
@@ -90,7 +94,7 @@ export class DsAddrBook implements AddrBook {
         if (!item) return acc 
         const addr = typeof item === 'string'   
           ?  multiaddr(item)   
-          : (item instanceof multiaddr ? item : null)  
+          : (isMultiaddr(item) ? item : null)  
         return addr ? [...acc, addr] : acc  
       } catch {  
         return acc 
@@ -116,7 +120,7 @@ export class DsAddrBook implements AddrBook {
       // 更新现有地址  
       outer: for (const [i, addr] of addrs.entries()) {  
         for (const entry of record.data.addrs) {  
-          if (addr.bytes == entry.addr) {  
+          if (bytes.compare(addr.bytes, entry.addr) === 0) {
             existed[i] = true  
             entry.ttl = ttl  
             entry.expiry = newExp  
@@ -138,6 +142,7 @@ export class DsAddrBook implements AddrBook {
       record.dirty = true  
       await this.cleanRecord(record)  
       await this.flushRecord(record)  
+      await this.invalidateEdge(t)
     } finally {  
       release()  
     }  
@@ -158,6 +163,7 @@ export class DsAddrBook implements AddrBook {
         }
         await this.cleanRecord(record)
         await this.flushRecord(record)
+        await this.invalidateEdge(t)
     } finally {
         release()
     }
@@ -217,43 +223,108 @@ async threadsFromAddrs(): Promise<ThreadID[]> {
     }
 }
 
-async addrsEdge(t: ThreadID): Promise<number> {
-    const key = this.genDSKey(t, DsAddrBook.logBookEdge.toString());
-    try {
-        const value = await this.ds.get(key);
-        return Number(new DataView(value.buffer).getBigUint64(0));
-    } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
-            throw err;
+
+
+
+    async addrsEdge(t: ThreadID, exceptPeerId?: string): Promise<bigint> {
+        const key = dsThreadKey(t, DsAddrBook.logBookEdge);
+        const retries = 3
+        for (let attempt = 1; attempt <= retries; attempt++) {
+            try {
+                return await this.calculateEdge(t, key, exceptPeerId);
+            } catch (err: any)  {
+                if (err.code !== 'TX_CONFLICT') throw err;
+                await this.randomDelay(attempt);
+            }
         }
+        throw new Error('Edge computation failed');
     }
 
-    const result =  this.ds.query({ prefix: this.genDSKey(t, DsAddrBook.logBookBase.toString()).toString()});
-    const now = Date.now();
-    const as: { logId: PeerId, addr: Uint8Array }[] = [];
+    private async calculateEdge(t: ThreadID, key: Key, exceptPeerId?: string): Promise<bigint> {
+        return this.withTransaction(async txn => {
+            try {
+                const data = await txn.get(key);
+                if (data) {
+                    return this.decodeStoredEdge(data);
+                }
+            } catch (err: any)  {
+                if (err.code !== 'ERR_NOT_FOUND') throw err;
+            }
 
-    for await (const entry of result) {
-        const { tid,pid, record } = this.decodeAddrEntry(entry, true);
-        if (!record) {
-            continue;
-        }
-        for (const addr of record.addrs) {
-            if (addr.expiry > now) {
-                as.push({ logId:pid, addr: addr.addr });
+            const addrs = await this.collectAddrs(txn, t, exceptPeerId);
+            if (addrs.length === 0) throw new Error('Thread not found');
+
+            const edge = this.computeAddrsEdge(addrs);
+            const buffer = Buffer.alloc(8);
+            this.writeEdgeValue(buffer, edge);
+
+            await txn.put(key, buffer);
+            return edge;
+        });
+    }
+
+    private async collectAddrs(txn: Transaction, t: ThreadID, exceptPeerId?: string): Promise<{ peerID: PeerId, addr: Uint8Array }[]> {
+        const query = { prefix: dsThreadKey(t, DsAddrBook.logBookBase).toString() };
+        const result = txn.query(query);
+        const now = Date.now();
+        const as: { peerID: PeerId, addr: Uint8Array }[] = [];
+
+        for await (const entry of result) {
+            const rawKey = entry.key as any;
+            const key = rawKey instanceof Key ? rawKey : new Key(rawKey.toString());
+            const pair: Pair = { key, value: entry.value };
+            const { tid,pid, record } = this.decodeAddrEntry(pair, true);
+            if (!record || (exceptPeerId && pid.toString() == exceptPeerId)) {
+                continue;
+            }
+            for (const addr of record.addrs) {
+                if (addr.expiry > now) {
+                    as.push({ peerID:pid, addr: addr.addr });
+                }
             }
         }
+        return as;
+    }
+
+    private async withTransaction<T>(fn: (txn: Transaction) => Promise<T>): Promise<T> {
+        const txn = await this.ds.newTransactionExtended(false);
+        try {
+            const result = await fn(txn);
+            await txn.commit();
+            return result;
+        } catch (err: any) {
+            txn.discard();
+            throw err;
+        }
     }
 
-    if (as.length === 0) {
-        throw new Error('Thread not found');
+    private decodeStoredEdge(data: Uint8Array): bigint {
+        const buf: any = Buffer.from(data);
+        const reader = buf as unknown as { readBigUInt64BE?: (offset?: number) => bigint };
+        if (buf.length >= 8 && typeof reader.readBigUInt64BE === 'function') {
+            return reader.readBigUInt64BE(0);
+        }
+        if (buf.length >= 4) {
+            return BigInt(buf.readUInt32BE(0));
+        }
+        throw new Error('Corrupted head edge value');
     }
 
-    const edge = this.computeAddrsEdge(as);
-    const buff = new ArrayBuffer(8);
-    new BigUint64Array(buff)[0] = BigInt(edge);
-    await this.ds.put(key, new Uint8Array(buff));
-    return edge;
-}
+    private writeEdgeValue(buf: any, value: bigint): void {
+        const writer = buf as unknown as { writeBigUInt64BE?: (val: bigint, offset?: number) => number };
+        if (typeof writer.writeBigUInt64BE === 'function') {
+            writer.writeBigUInt64BE(value, 0);
+            return;
+        }
+        buf.writeUInt32BE(Number(value & 0xffffffffn), 0);
+    }
+
+    private randomDelay(attempt: number): Promise<void> {
+        const delay = 50 * attempt + Math.random() * 30;
+        return new Promise(resolve =>
+            setTimeout(resolve, delay)
+        );
+    }
 
 
 
@@ -343,10 +414,11 @@ private async traverse(withAddrs: boolean): Promise<{ [key: string]: { [key: str
 }
 
 
-    private decodeAddrEntry(entry: Pair, withAddrs: boolean): { tid: ThreadID, pid: PeerId, record?: pb.AddrBookRecord } {
-        const kns = entry.key.toString().split('/');
+    private decodeAddrEntry(entry: any, withAddrs: boolean): { tid: ThreadID, pid: PeerId, record?: pb.AddrBookRecord } {
+        const keyStr = typeof entry.key === 'string' ? entry.key : entry.key.toString();
+        const kns = keyStr.split('/');
         if (kns.length < 3) {
-            throw new Error(`bad addressbook key detected: ${entry.key}`);
+            throw new Error(`bad addressbook key detected: ${keyStr}`);
         }
 
         // get thread and log IDs from the key components
@@ -366,25 +438,39 @@ private async traverse(withAddrs: boolean): Promise<{ [key: string]: { [key: str
 
       
 
-    private computeAddrsEdge(as: { logId: PeerId, addr: Uint8Array }[]): number {
-        const sorted = [...as].sort((a, b) => {
-            const left = a.logId.toString();
-            const right = b.logId.toString();
-            if (left === right) {
-                return bytes.compare(a.addr, b.addr);
+    private computeAddrsEdge(as: { peerID: PeerId, addr: Uint8Array }[]): bigint {
+        const entries = as.map(item => ({
+            peerIDBytes: this.decodePeerId(item.peerID.toString(), new TextEncoder()),
+            addr: item.addr,
+        }));
+
+        entries.sort((a, b) => {
+            const peerIDCompare = bytes.compare(a.peerIDBytes, b.peerIDBytes);
+            if (peerIDCompare !== 0) {
+                return peerIDCompare;
             }
-            return left < right ? -1 : 1;
+            return bytes.compare(a.addr, b.addr);
         });
 
-        const encoder = new TextEncoder();
         let hash = ADDR_FNV_OFFSET_BASIS;
 
-        for (const item of sorted) {
-            hash = this.fnv1a64(encoder.encode(item.logId.toString()), hash);
-            hash = this.fnv1a64(item.addr, hash);
+        for (const entry of entries) {
+            hash = this.fnv1a64(entry.peerIDBytes, hash);
+            hash = this.fnv1a64(entry.addr, hash);
         }
 
-        return Number(hash);
+        return hash;
+    }
+
+ private decodePeerId(peerID: string, encoder: TextEncoder): Uint8Array {
+        if (!peerID) {
+            return new Uint8Array();
+        }
+        try {
+            return bases.base58btc.baseDecode(peerID);
+        } catch (err: any) {
+            return encoder.encode(peerID);
+        }
     }
 
     private fnv1a64(data: Uint8Array, initial: bigint): bigint {
@@ -460,4 +546,4 @@ class AsyncMutex {
       next?.()  
     }  
   }  
-}  
+}

package/lib/implements/threaddb/lsstoreds/headbook.ts

@@ -1,5 +1,7 @@
 import { CID } from 'multiformats/cid';
 import { Key,Pair } from 'interface-datastore';
+import { bases } from 'multiformats/basics';
+
 import { Head, HeadBookRecord, serializeHeadBookRecord, deserializeHeadBookRecord } from '../core/head';
 import {
     TxnDatastoreExtended,
@@ -151,7 +153,7 @@ export class DsHeadBook implements HeadBook {
         await txn.put(key, recordBytes);
     }
 
-    async headsEdge(tid: ThreadID, retries = 3): Promise<number> {
+    async headsEdge(tid: ThreadID, retries = 3): Promise<bigint> {
         const key = dsThreadKey(tid, hbEdge);
 
         for (let attempt = 1; attempt <= retries; attempt++) {
@@ -165,7 +167,7 @@ export class DsHeadBook implements HeadBook {
         throw new Error('Edge computation failed');
     }
 
-    private async calculateEdge(tid: ThreadID, key: Key): Promise<number> {
+    private async calculateEdge(tid: ThreadID, key: Key): Promise<bigint> {
         return this.withTransaction(async txn => {
             try {
                 const data = await txn.get(key);
@@ -184,7 +186,7 @@ export class DsHeadBook implements HeadBook {
             this.writeEdgeValue(buffer, edge);
 
             await txn.put(key, buffer);
-            return Number(edge);
+            return edge;
         });
     }
 
@@ -217,27 +219,49 @@ export class DsHeadBook implements HeadBook {
         return heads;
     }
 
-    private computeHeadsEdge(hs: LogHead[]): bigint {
-  const sorted = [...hs].sort((a, b) => {
-    if (a.logId === b.logId) {
-      const left = a.head.id?.toString() ?? '';
-      const right = b.head.id?.toString() ?? '';
-      return left.localeCompare(right);
-    }
-    return a.logId.localeCompare(b.logId);
-  });
+        private computeHeadsEdge(hs: LogHead[]): bigint {
+                const sorted = [...hs].sort((a, b) => {
+                        if (a.logId === b.logId) {
+                                return this.compareCidBytes(a.head.id?.bytes, b.head.id?.bytes);
+                        }
+                        return a.logId.localeCompare(b.logId);
+                });
 
-  const encoder = new TextEncoder();
-  let hash = FNV_OFFSET_BASIS;
+                const encoder = new TextEncoder();
+                let hash = FNV_OFFSET_BASIS;
 
-  for (const item of sorted) {
-    hash = this.fnv1a64(encoder.encode(item.logId), hash);
-    const headBytes = item.head.id?.bytes ?? new Uint8Array();
-    hash = this.fnv1a64(headBytes, hash);
-  }
+                for (const item of sorted) {
+                    const logIdBytes = this.decodeLogId(item.logId, encoder);
+                    hash = this.fnv1a64(logIdBytes, hash);
+                        const headBytes = item.head.id?.bytes ?? new Uint8Array();
+                        hash = this.fnv1a64(headBytes, hash);
+                }
 
-    return hash;
-}
+                return hash;
+        }
+
+        private compareCidBytes(left?: Uint8Array, right?: Uint8Array): number {
+                const a = left ?? new Uint8Array();
+                const b = right ?? new Uint8Array();
+                const min = Math.min(a.length, b.length);
+                for (let i = 0; i < min; i++) {
+                        if (a[i] !== b[i]) {
+                                return a[i] - b[i];
+                        }
+                }
+                return a.length - b.length;
+        }
+
+    private decodeLogId(logId: string, encoder: TextEncoder): Uint8Array {
+        if (!logId) {
+            return new Uint8Array();
+        }
+        try {
+            return bases.base58btc.baseDecode(logId);
+        } catch (err: any) {
+            return encoder.encode(logId);
+        }
+    }
 
 private fnv1a64(data: Uint8Array, initial: bigint): bigint {
   let hash = initial;
@@ -253,14 +277,14 @@ private fnv1a64(data: Uint8Array, initial: bigint): bigint {
         await txn.delete(key);
     }
 
-    private decodeStoredEdge(data: Uint8Array): number {
+    private decodeStoredEdge(data: Uint8Array): bigint {
         const buf: any = Buffer.from(data);
         const reader = buf as unknown as { readBigUInt64BE?: (offset?: number) => bigint };
         if (buf.length >= 8 && typeof reader.readBigUInt64BE === 'function') {
-            return Number(reader.readBigUInt64BE(0));
+            return reader.readBigUInt64BE(0);
         }
         if (buf.length >= 4) {
-            return buf.readUInt32BE(0);
+            return BigInt(buf.readUInt32BE(0));
         }
         throw new Error('Corrupted head edge value');
     }

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

@@ -82,6 +82,7 @@ import {
 import * as buffer from "buffer/";
 import { AsyncMutex } from "../common/AsyncMutex";
 import { DCContext } from "../../../interfaces";
+import { time } from "console";
 const { Buffer } = buffer;
 
 /**
@@ -811,7 +812,12 @@ export class Network implements Net {
       managed: true,
       head: head,
     } as IThreadLogInfo;
-
+    //标记本地log没有生成任何记录
+      await this.logstore.metadata.putString(
+        id,
+        "local_log_no_record_flag",
+        `${peerId.toString()}`
+      );  
     // 将日志添加到threaddb存储
     await this.logstore.addLog(id, logInfo);
     const logIDBytes = new TextEncoder().encode(peerId.toString());
@@ -1759,7 +1765,7 @@ export class Network implements Net {
 
       const sleep = (ms: number) =>
         new Promise<void>((resolve) => setTimeout(resolve, ms));
-
+      let haveRecordFlag = false;
       const loop = async () => {
         while (true) {
           try {
@@ -1770,6 +1776,15 @@ export class Network implements Net {
             }
             try {
               await this._doPushRecord(item.tid, item.lid, item.rec, item.counter);
+              if (!haveRecordFlag) {
+                  await this.logstore.metadata.putString(
+                  item.tid,
+                  "local_log_no_record_flag",
+                  ""
+                );
+                haveRecordFlag = true;
+              }
+              
             } catch (err) {
               console.error("pushRecord failed:", err);
               await sleep(200); // 简单退避，避免持续报错阻塞后续任务
@@ -1815,7 +1830,7 @@ export class Network implements Net {
             dbClient = new DBClient(client, this.dc, this, this.logstore);
             await dbClient.pushRecordToPeer(tid, lid, rec, counter);
           } catch (err) {
-            if (dbClient && err.message == Errors.ErrLogNotFound.message) { //log文件没绑定,进行绑定
+            if (err instanceof Error && dbClient && err.message === Errors.ErrLogNotFound.message) { //log文件没绑定,进行绑定
              try {
                   await this.context.dbManager?.addLogToThreadStart(null,tid, lid);
                   const err = await dbClient.pushLogToPeer(tid, lid,rec); //推送本地log文件到对等节点,rec表示最新的记录

package/lib/implements/wallet/manager.ts

@@ -139,6 +139,7 @@ export class WalletManager {
           //非钱包插件
           return;
         }
+        console.log("debug================listenForWalletLoaded", new Date());
         if (data.type === "walletLoaded") {
           //钱包加载完成
           walletLoadedFlag = true;
@@ -158,7 +159,7 @@ export class WalletManager {
           clearInterval(interval);
           messageChannel.port1.close();
         } else {
-          if (waitTimeCount >= 0) {
+          if (waitTimeCount > 0) {
             waitTimeCount--;
           } else {
             try {
@@ -218,7 +219,6 @@ export class WalletManager {
       (iframe as any).credentialless = true; // 去掉可以加快加载
       iframe.onload = async () => {
         console.log("debug================onload", new Date());
-        resolve(true);
       };
       iframe.onerror = (error) => {
         console.error("openWallet error", error);
@@ -250,6 +250,7 @@ export class WalletManager {
       iframe.allowFullscreen = true;
       document.body.appendChild(iframe);
       console.log("debug================appendChild", new Date());
+      resolve(true);
     });
   }
 
@@ -549,6 +550,7 @@ export class WalletManager {
         return;
       }
       if (message.type === "walletLoaded") {
+        console.log("debug================walletLoaded", new Date());
         console.log("walletLoaded", message);
         console.log("event.origin", event.origin);
         console.log("walletOrigin", walletOrigin);

package/lib/modules/auth-module.ts

@@ -488,8 +488,8 @@ export class AuthModule implements DCModule, IAuthOperations {
       }
       this.tokenTask = true;
 
-      // 300秒一次心跳维持连接
-      const period = 1000;
+      // 60秒一次心跳维持连接
+      const period = 60*1000;
       let count = 0;
       let waitCount = 0;