web-dc-api 0.0.58 → 0.0.60

package/dist/esm/implements/threaddb/net/define.js

@@ -0,0 +1,79 @@
+import { protocols } from 'multiaddr';
+
+const netPullingLimit = 1000; // 拉取记录数的限制
+// 协议常量定义  
+const Protocol = {
+  code: 406,
+  // 根据实际协议代码调整  
+  name: 'thread',
+  // 协议名称  
+  version: "0.0.1",
+  resolvable: false,
+  path: false,
+  size: -1
+};
+const V = -1;
+const table = [[4, 32, 'ip4'], [6, 16, 'tcp'], [33, 16, 'dccp'], [41, 128, 'ip6'], [42, V, 'ip6zone'], [43, 8, 'ipcidr'], [53, V, 'dns', true], [54, V, 'dns4', true], [55, V, 'dns6', true], [56, V, 'dnsaddr', true], [132, 16, 'sctp'], [273, 16, 'udp'], [275, 0, 'p2p-webrtc-star'], [276, 0, 'p2p-webrtc-direct'], [277, 0, 'p2p-stardust'], [280, 0, 'webrtc-direct'], [281, 0, 'webrtc'], [290, 0, 'p2p-circuit'], [301, 0, 'udt'], [302, 0, 'utp'], [400, V, 'unix', false, true],
+// `ipfs` is added before `p2p` for legacy support.
+// All text representations will default to `p2p`, but `ipfs` will
+// still be supported
+[421, V, 'ipfs'],
+// `p2p` is the preferred name for 421, and is now the default
+[421, V, 'p2p'], [443, 0, 'https'], [444, 96, 'onion'], [445, 296, 'onion3'], [446, V, 'garlic64'], [448, 0, 'tls'], [449, V, 'sni'], [460, 0, 'quic'], [461, 0, 'quic-v1'], [465, 0, 'webtransport'], [466, V, 'certhash'], [477, 0, 'ws'], [478, 0, 'wss'], [479, 0, 'p2p-websocket-star'], [480, 0, 'http'], [481, V, 'http-path'], [777, V, 'memory']];
+function createProtocol(code, size, name, resolvable, path) {
+  return {
+    code,
+    size,
+    name,
+    resolvable: Boolean(resolvable),
+    path: Boolean(path)
+  };
+}
+// populate tables
+table.forEach(row => {
+  const proto = createProtocol(...row);
+  if (!protocols.codes[proto.code]) {
+    protocols.codes[proto.code] = proto;
+    protocols.names[proto.name] = proto;
+  }
+});
+if (!protocols.codes[Protocol.code]) {
+  protocols.codes[Protocol.code] = Protocol;
+  protocols.names[Protocol.name] = Protocol;
+}
+/**
+ * Record implements IThreadRecord
+ */
+class ThreadRecord {
+  constructor(record, _threadID, _logID) {
+    Object.defineProperty(this, "record", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: record
+    });
+    Object.defineProperty(this, "_threadID", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: _threadID
+    });
+    Object.defineProperty(this, "_logID", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: _logID
+    });
+  }
+  value() {
+    return this.record;
+  }
+  threadID() {
+    return this._threadID;
+  }
+  logID() {
+    return this._logID;
+  }
+}
+
+export { Protocol, ThreadRecord, netPullingLimit, table };

package/dist/esm/implements/threaddb/net/grpcClient.js

@@ -0,0 +1,432 @@
+import { ThreadID } from '@textile/threads-id';
+import { dcnet } from '../../../proto/dcnet_proto.js';
+import { net } from '../pb/net_pb.js';
+import { Libp2pGrpcClient } from 'grpc-libp2p-client';
+import { multiaddr, protocols } from '@multiformats/multiaddr';
+import { toString } from '../../../node_modules/uint8arrays/dist/src/to-string.js';
+import { Ed25519PubKey, Ed25519PrivKey } from '../../../common/dc-key/ed25519.js';
+import { extractPeerIdFromMultiaddr, extractPublicKeyFromPeerId } from '../../../common/dc-key/keyManager.js';
+import { ThreadMuliaddr, ThreadInfo } from '../core/core.js';
+import { CID } from '../../../node_modules/multiformats/dist/src/cid.js';
+import { Protocol } from './define.js';
+import { RecordFromProto, RecordToProto, logToProto } from '../cbor/record.js';
+import { decode, encodingLength } from '../../../node_modules/uint8-varint/dist/src/index.js';
+import { PeerIDConverter, MultiaddrConverter, CidConverter, ThreadIDConverter } from '../pb/proto-custom-types.js';
+import * as index from '../../../_virtual/index.js';
+import { Errors } from '../core/db.js';
+
+const {
+  Buffer
+} = index;
+class DBGrpcClient {
+  constructor(node, peerAddr, token, net, protocol) {
+    Object.defineProperty(this, "grpcClient", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "stream", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "token", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "net", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.grpcClient = new Libp2pGrpcClient(node, peerAddr, token, protocol);
+    this.token = token;
+    this.net = net;
+  }
+  async requestThreadID() {
+    try {
+      const message = new dcnet.pb.ThreadIDRequest({});
+      const messageBytes = dcnet.pb.ThreadIDRequest.encode(message).finish();
+      const responseData = await this.grpcClient.unaryCall("/dcnet.pb.Service/RequestThreadID", messageBytes, 30000);
+      const decoded = dcnet.pb.ThreadIDReply.decode(responseData);
+      return toString(decoded.threadID);
+    } catch (err) {
+      console.error("RequestThreadID error:", err);
+      throw err;
+    }
+  }
+  async createThread(tid, opts) {
+    try {
+      if (this.grpcClient.node == null || this.grpcClient.node.peerId == null) {
+        throw new Error("p2pNode is null or node privateKey is null");
+      }
+      if (opts.threadKey == null) {
+        throw new Error("threadKey is null");
+      }
+      const serverPeerId = await extractPeerIdFromMultiaddr(this.grpcClient.peerAddr);
+      const sPubkey = await extractPublicKeyFromPeerId(serverPeerId);
+      const message = new dcnet.pb.CreateThreadRequest({});
+      message.threadID = new TextEncoder().encode(tid);
+      message.keys = await this.getThreadKeys(sPubkey, {
+        threadKey: opts.threadKey,
+        logKey: opts.logKey
+      });
+      message.blockheight = opts.blockHeight;
+      message.signature = opts.signature;
+      const messageBytes = dcnet.pb.CreateThreadRequest.encode(message).finish();
+      const responseData = await this.grpcClient.unaryCall("/dcnet.pb.Service/CreateThread", messageBytes, 30000);
+      const reply = dcnet.pb.ThreadInfoReply.decode(responseData);
+      const threadInfo = await this.threadInfoFromProto(reply);
+      return threadInfo;
+    } catch (err) {
+      console.error("CreateThread error:", err);
+      throw err;
+    }
+  }
+  async addLogToThread(tid, lid, opts) {
+    try {
+      if (this.grpcClient.node == null || this.grpcClient.node.peerId == null) {
+        throw new Error("p2pNode is null or node privateKey is null");
+      }
+      const serverPeerId = this.grpcClient.node.peerId;
+      const sPubkey = await extractPublicKeyFromPeerId(serverPeerId);
+      const message = new dcnet.pb.AddLogToThreadRequest({});
+      message.threadID = new TextEncoder().encode(tid);
+      message.logID = new TextEncoder().encode(lid);
+      message.peerid = new TextEncoder().encode(serverPeerId.toString());
+      message.blockheight = opts.blockHeight;
+      message.signature = opts.signature;
+      const messageBytes = dcnet.pb.AddLogToThreadRequest.encode(message).finish();
+      await this.grpcClient.unaryCall("/dcnet.pb.Service/AddLogToThread", messageBytes, 30000);
+    } catch (err) {
+      if (err.message.includes("log has binded to thread")) {
+        return;
+      }
+      throw err;
+    }
+  }
+  async threadInfoFromProto(reply) {
+    if (!reply.threadID) {
+      throw new Error('Missing required field: threadID');
+    }
+    const threadID = ThreadID.fromString(new TextDecoder().decode(reply.threadID));
+    const logs = reply.logs ? await Promise.all(reply.logs.map(async lg => {
+      if (!lg.ID || !lg.pubKey) {
+        throw new Error('Missing required fields in LogInfo: id or pubKey');
+      }
+      const id = PeerIDConverter.fromBytes(lg.ID);
+      //  //logid 解析更新
+      //    const multihash = decode(lg.ID);
+      //   const id = peerIdFromMultihash(multihash);
+      const pubKey = Ed25519PubKey.publicKeyFromProto(lg.pubKey);
+      let privKey = undefined;
+      if (lg.privKey?.length == 64) {
+        privKey = Ed25519PrivKey.privateKeyFromProto(lg.privKey);
+      }
+      const addrs = lg.addrs?.map(addr => MultiaddrConverter.fromBytes(addr)) || [];
+      const head = lg.head ? CidConverter.fromBytes(lg.head) : null;
+      let counter = -1;
+      if (lg.counter && lg.counter.length > 0) {
+        const counterBuffer = Buffer.from(lg.counter);
+        counter = Number(counterBuffer.readBigUInt64BE(0));
+      }
+      return {
+        id,
+        pubKey,
+        ...(privKey ? {
+          privKey
+        } : {}),
+        addrs,
+        managed: true,
+        head: {
+          id: head || CID.parse(''),
+          counter
+        }
+      };
+    })) : [];
+    const addrs = [];
+    if (reply.addrs && reply.addrs.length > 0) {
+      for (const addrBytes of reply.addrs) {
+        try {
+          //addrBytes 移除code为406,长度为-1的数据
+          // 处理含有 /thread 协议的多地址
+          // thread 协议码为 406
+          let processedBytes = this.removeThreadProtocol(addrBytes);
+          // 使用处理后的字节创建多地址
+          let addr = multiaddr(processedBytes);
+          const threadMultiaddr = new ThreadMuliaddr(addr, threadID);
+          addrs.push(threadMultiaddr);
+        } catch (addrErr) {
+          console.warn(`Skipping invalid multiaddr: ${addrErr.message}`);
+          // Continue with other addresses
+        }
+      }
+    }
+    const threadInfo = new ThreadInfo(threadID, logs, addrs);
+    return threadInfo;
+  }
+  removeThreadProtocol(bytes) {
+    let i = 0;
+    while (i < bytes.length) {
+      const code = decode(bytes, i);
+      if (code == Protocol.code) {
+        // 406,截取前面的数据
+        return bytes.slice(0, i);
+      }
+      const n = encodingLength(code);
+      const p = protocols(code);
+      const size = this.sizeForAddr(p, bytes.slice(i + n));
+      if (size === 0) {
+        i += n;
+        continue;
+      }
+      bytes.slice(i + n, i + n + size);
+      i += size + n;
+      if (i > bytes.length) {
+        throw new Error('invalid multiaddr');
+      }
+      if (p.path === true) {
+        break;
+      }
+    }
+    return bytes;
+  }
+  sizeForAddr(p, addr) {
+    if (p.size > 0) {
+      return p.size / 8;
+    } else if (p.size === 0) {
+      return 0;
+    } else {
+      const size = decode(addr instanceof Uint8Array ? addr : Uint8Array.from(addr));
+      return size + encodingLength(size);
+    }
+  }
+  async getThreadKeys(sPubkey, args) {
+    try {
+      const threadKeyEncrypt = await sPubkey.encrypt(args.threadKey.toBytes());
+      let logKeyEncrpt;
+      if (args.logKey) {
+        if (args.logKey instanceof Ed25519PrivKey) {
+          logKeyEncrpt = await sPubkey.encrypt(Ed25519PubKey.publicKeyToProto(args.logKey.publicKey));
+        } else if (args.logKey instanceof Ed25519PubKey) {
+          logKeyEncrpt = await sPubkey.encrypt(Ed25519PubKey.publicKeyToProto(args.logKey));
+        } else {
+          logKeyEncrpt = await sPubkey.encrypt(args.logKey.raw);
+        }
+      } else {
+        logKeyEncrpt = await sPubkey.encrypt(new Uint8Array(0));
+      }
+      const keys = new dcnet.pb.Keys({
+        threadKeyEncrpt: threadKeyEncrypt,
+        logKeyEncrpt: logKeyEncrpt
+      });
+      return keys;
+    } catch (err) {
+      console.error("getThreadKeys error:", err);
+      throw err;
+    }
+  }
+  /**
+   * 从特定对等点获取记录
+   * 注意: 这是一个假设的实现，需要根据你的实际gRPC客户端实现来调整
+   */
+  async getRecordsFromPeer(req, serviceKey) {
+    try {
+      // 编码请求消息
+      const messageBytes = net.pb.GetRecordsRequest.encode(req).finish();
+      // 调用 gRPC 方法
+      const responseData = await this.grpcClient.unaryCall("/net.pb.Service/GetRecords", messageBytes, 30000);
+      // 解码响应
+      const response = net.pb.GetRecordsReply.decode(responseData);
+      // 处理响应数据
+      const result = {};
+      for (const logInfo of response.logs || []) {
+        if (!logInfo.logID) continue;
+        const logId = PeerIDConverter.fromBytes(logInfo.logID).toString();
+        // const multihash = decode(logInfo.logID);
+        // const logId = peerIdFromMultihash(multihash).toString();
+        const rawRecords = logInfo.records || [];
+        // 并行转换所有记录
+        const recordPromises = rawRecords.map(async rec => {
+          return await RecordFromProto(rec, serviceKey);
+        });
+        // 等待所有记录转换完成
+        const unsortedRecords = await Promise.all(recordPromises);
+        // 根据链表结构排序记录
+        const sortedRecords = this.sortRecordsChain(unsortedRecords);
+        result[logId] = {
+          records: sortedRecords,
+          counter: logInfo.log?.counter || 0
+        };
+      }
+      return result;
+    } catch (err) {
+      console.error(`getRecordsFromPeer error:`, err);
+      throw err;
+    }
+  }
+  /**
+  * 根据链表结构排序记录
+  * 确保第二个记录的 prevID() 等于第一个记录的 blockID()，以此类推
+  */
+  sortRecordsChain(records) {
+    if (records.length <= 1) {
+      return records;
+    }
+    const sorted = [];
+    const recordMap = new Map();
+    let headRecord = null;
+    // 建立 blockID 到记录的映射
+    for (const record of records) {
+      const blockId = record.blockID().toString();
+      recordMap.set(blockId, record);
+    }
+    // 找到链表头部（没有前驱的记录）
+    for (const record of records) {
+      const prevId = record.prevID();
+      if (!prevId || !recordMap.has(prevId.toString())) {
+        // 这是头部记录（没有前驱或前驱不在当前记录集合中）
+        headRecord = record;
+        break;
+      }
+    }
+    if (!headRecord) {
+      // 如果找不到明确的头部，尝试找到最早的记录
+      console.warn('No clear head record found, using first record as head');
+      headRecord = records[0] ? records[0] : null;
+    }
+    // 从头部开始构建有序链表
+    let currentRecord = headRecord;
+    const processed = new Set();
+    while (currentRecord && !processed.has(currentRecord.blockID().toString())) {
+      sorted.push(currentRecord);
+      processed.add(currentRecord.blockID().toString());
+      // 查找下一个记录（prevID 指向当前记录的 blockID）
+      const currentBlockId = currentRecord.blockID().toString();
+      let nextRecord = null;
+      for (const record of records) {
+        if (processed.has(record.blockID().toString())) {
+          continue; // 已处理过
+        }
+        const prevId = record.prevID();
+        if (prevId && prevId.toString() === currentBlockId) {
+          nextRecord = record;
+          break;
+        }
+      }
+      currentRecord = nextRecord;
+    }
+    // 检查是否所有记录都被处理了
+    if (sorted.length !== records.length) {
+      console.warn(`Chain sorting incomplete: sorted ${sorted.length}/${records.length} records. ` + 'Some records may not form a continuous chain.');
+      // 将未处理的记录追加到末尾
+      for (const record of records) {
+        if (!processed.has(record.blockID().toString())) {
+          sorted.push(record);
+        }
+      }
+    }
+    return sorted;
+  }
+  async pushRecordToPeer(tid, lid, rec, counter, logstore) {
+    try {
+      const body = new net.pb.PushRecordRequest.Body();
+      body.threadID = ThreadIDConverter.toBytes(tid.toString());
+      body.logID = PeerIDConverter.toBytes(lid.toString());
+      body.record = await RecordToProto(this.net.bstore, rec);
+      const message = new net.pb.PushRecordRequest();
+      message.body = body;
+      message.counter = counter;
+      // 编码请求
+      const messageBytes = net.pb.PushRecordRequest.encode(message).finish();
+      // 调用gRPC方法
+      await this.grpcClient.unaryCall("/net.pb.Service/PushRecord", messageBytes, 30000);
+    } catch (err) {
+      if (err.message == Errors.ErrLogNotFound.message) {
+        try {
+          const timeout = setTimeout(() => {
+            throw new Error('Getting log information timed out');
+          }, 30000); // 30秒超时 (PushTimeout)
+          // 获取日志信息
+          const log = await logstore.getLog(tid, lid);
+          clearTimeout(timeout); // 清除超时
+          // 准备日志推送请求
+          const logBody = new net.pb.PushLogRequest.Body();
+          logBody.threadID = ThreadIDConverter.toBytes(tid.toString());
+          logBody.log = await logToProto(log);
+          const logRequest = new net.pb.PushLogRequest();
+          logRequest.body = logBody;
+          // 推送缺失的日志
+          const logMessageBytes = net.pb.PushLogRequest.encode(logRequest).finish();
+          await this.grpcClient.unaryCall("/net.pb.Service/PushLog", logMessageBytes, 30000);
+          return;
+        } catch (logErr) {
+          throw new Error(`Error pushing missing log: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
+        }
+      }
+    }
+  }
+  async exchangeEdges(req) {
+    try {
+      const messageBytes = net.pb.ExchangeEdgesRequest.encode(req).finish();
+      // 调用 gRPC 方法
+      const response = await this.grpcClient.unaryCall("/net.pb.Service/ExchangeEdges", messageBytes, 30000);
+      // 解码响应
+      const reply = net.pb.ExchangeEdgesReply.decode(response);
+      return reply;
+    } catch (err) {
+      console.error("exchangeEdges error:", err);
+      throw err;
+    }
+  }
+  /**
+   * 获取threaddb 中的日志
+   * @param tid threaddb ID
+   * @returns 日志信息数组
+   */
+  async getLogs(tid, sk) {
+    try {
+      const body = new net.pb.GetLogsRequest.Body();
+      body.threadID = tid.toBytes();
+      body.serviceKey = sk;
+      const req = new net.pb.GetLogsRequest();
+      req.body = body;
+      // 编码请求
+      const messageBytes = net.pb.GetLogsRequest.encode(req).finish();
+      // 调用 gRPC 方法
+      const response = await this.grpcClient.unaryCall("/net.pb.Service/GetLogs", messageBytes, 30000 // 设置超时时间为30秒
+      );
+      // 解码响应
+      const reply = net.pb.GetLogsReply.decode(response);
+      return reply;
+    } catch (err) {
+      console.error(`getLogs error for peer ${this.grpcClient.peerAddr.toString()}:`, err);
+      throw err;
+    }
+  }
+  async getThreadFromPeer(tid) {
+    try {
+      const req = new dcnet.pb.GetThreadRequest();
+      req.threadID = tid.toBytes();
+      // 编码请求
+      const messageBytes = dcnet.pb.GetThreadRequest.encode(req).finish();
+      // 调用 gRPC 方法
+      const response = await this.grpcClient.unaryCall("/dcnet.pb.Service/GetThread", messageBytes, 30000 // 设置超时时间为30秒
+      );
+      // 解码响应
+      const reply = dcnet.pb.ThreadInfoReply.decode(response);
+      const threadInfo = await this.threadInfoFromProto(reply);
+      return threadInfo;
+    } catch (err) {
+      console.error(`getThreadFromPeer error for peer ${this.grpcClient.peerAddr.toString()}:`, err);
+      throw err;
+    }
+  }
+}
+
+export { DBGrpcClient };

package/dist/esm/implements/threaddb/net/grpcserver.js

@@ -0,0 +1,139 @@
+import { CID } from '../../../node_modules/multiformats/dist/src/cid.js';
+import { multiaddr } from '@multiformats/multiaddr';
+import { StreamWriter } from '../../../node_modules/grpc-libp2p-client/dist/dc-http2/stream.esm.js';
+import { Http2Frame } from '../../../node_modules/grpc-libp2p-client/dist/dc-http2/frame.esm.js';
+import { net } from '../pb/net_pb.js';
+import { HTTP2Parser } from '../../../node_modules/grpc-libp2p-client/dist/dc-http2/parser.esm.js';
+import { HPACK } from '../../../node_modules/grpc-libp2p-client/dist/dc-http2/hpack.esm.js';
+import { keys } from '@libp2p/crypto';
+import { ThreadIDConverter, ProtoKeyConverter, MultiaddrConverter, KeyConverter, CidConverter, PeerIDConverter } from '../pb/proto-custom-types.js';
+
+class DCGrpcServer {
+  constructor(libp2p, protocol) {
+    Object.defineProperty(this, "libp2p", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: libp2p
+    });
+    Object.defineProperty(this, "protocol", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: protocol
+    });
+  }
+  start() {
+    this.libp2p.handle(this.protocol, async _ref => {
+      let {
+        stream
+      } = _ref;
+      try {
+        const hpack = new HPACK();
+        //生成number的streamId
+        let method = "";
+        const writer = new StreamWriter(stream.sink);
+        const http2Parser = new HTTP2Parser(writer);
+        http2Parser.onData = async (payload, frameHeader) => {
+          const requestData = payload.subarray(5); // 去除帧头部分
+          if (method === "/net.pb.Service/GetLogs") {
+            this.getLogs(frameHeader.streamId, requestData, writer);
+          }
+        };
+        http2Parser.onSettings = async () => {
+          const ackSettingFrame = Http2Frame.createSettingsAckFrame();
+          writer.write(ackSettingFrame);
+        };
+        http2Parser.onHeaders = (headers, header) => {
+          const plainHeaders = hpack.decodeHeaderFields(headers);
+          method = plainHeaders.get(':path');
+        };
+        http2Parser.processStream(stream);
+      } catch (err) {
+        console.error("Error handling request:", err);
+      }
+    });
+  }
+  stop() {
+    this.libp2p.stop();
+  }
+  _parseFrameHeader(buffer) {
+    if (buffer.length < 9) {
+      throw new Error("Invalid frame header length");
+    }
+    const length = buffer[0] << 16 | buffer[1] << 8 | buffer[2];
+    const type = buffer[3];
+    const flags = buffer[4];
+    const streamId = buffer[5] << 24 | buffer[6] << 16 | buffer[7] << 8 | buffer[8];
+    return {
+      length,
+      type,
+      flags,
+      streamId,
+      payload: buffer.slice(0, 9)
+    };
+  }
+  async getLogs(streamId, request, writer) {
+    console.log('Received GetLogs request');
+    const req = net.pb.GetLogsRequest.decode(request);
+    if (req.body?.threadID) {
+      const threadId = ThreadIDConverter.fromBytes(req.body?.threadID);
+      console.log('Thread ID:', threadId.toString());
+    }
+    if (req.body?.serviceKey) {
+      const serviceKey = ProtoKeyConverter.fromBytes(req.body?.serviceKey);
+      console.log('Service Key:', serviceKey.toString());
+    }
+    const response = new net.pb.GetLogsReply();
+    const keyPair = await keys.generateKeyPair("Ed25519");
+    // 获取公钥
+    const publicKey = keyPair.publicKey;
+    const pid = this.libp2p.peerId.toString();
+    // const headBytes  = new TextEncoder().encode("bafybeiai3u5rmdsbmqklo7icdn3x5suoyepu2mqms3vgj4rvnkuyjnivmy")
+    const head = CID.parse("bafybeiai3u5rmdsbmqklo7icdn3x5suoyepu2mqms3vgj4rvnkuyjnivmy");
+    const addr = MultiaddrConverter.toBytes(multiaddr('/ip4/10.0.0.1/tcp/4001/p2p/' + pid));
+    let pubkeyBytes = await KeyConverter.publicToBytes(publicKey);
+    const addrs = [];
+    addrs.push(addr);
+    const log = new net.pb.Log({
+      /** Log ID */
+      ID: PeerIDConverter.toBytes(pid),
+      /** Log pubKey */
+      pubKey: pubkeyBytes,
+      /** Log addrs */
+      addrs: addrs,
+      /** Log head */
+      head: CidConverter.toBytes(head),
+      /** Log counter */
+      counter: 0
+    });
+    for (var i = 0; i < 5000; i++) {
+      //模拟5000个log信息,测试大数据grpc请求是否正常
+      response.logs.push(log);
+    }
+    const headlist = {
+      ':status': '200',
+      'content-type': 'application/grpc'
+    };
+    // 设置响应头部
+    const headerResponseFrame = Http2Frame.createResponseHeadersFrame(streamId, headlist, true);
+    await writer.write(headerResponseFrame);
+    // 创建数据帧
+    const bytes = net.pb.GetLogsReply.encode(response).finish();
+    const dataFrame = Http2Frame.createDataFrame(streamId, bytes, false);
+    await writer.write(dataFrame);
+    //发送tailer
+    const trailers = {
+      'grpc-status': '0',
+      // 表示成功
+      'grpc-message': 'Operation completed successfully'
+    };
+    const trailersFrame = Http2Frame.createTrailersFrame(streamId, trailers);
+    console.log('Trailers Frame:', trailersFrame);
+    await writer.write(trailersFrame);
+    await writer.end();
+    return;
+  }
+}
+
+export { DCGrpcServer };