web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/common/dcutil.js

@@ -0,0 +1,621 @@
+'use strict';
+
+var multiaddr = require('@multiformats/multiaddr');
+var datastoreIdb = require('datastore-idb');
+var blockstoreIdb = require('blockstore-idb');
+var crypto = require('@libp2p/crypto');
+var index$6 = require('../node_modules/@libp2p/webrtc/dist/src/index.js');
+var helia = require('helia');
+var libp2p = require('libp2p');
+var index$1 = require('../node_modules/@libp2p/identify/dist/src/index.js');
+var index$4 = require('../node_modules/@chainsafe/libp2p-yamux/dist/src/index.js');
+var index$5 = require('../node_modules/@chainsafe/libp2p-noise/dist/src/index.js');
+var utils = require('../util/utils.js');
+var index = require('../node_modules/@libp2p/ping/dist/src/index.js');
+var streamwriter = require('../implements/file/streamwriter.js');
+var index$8 = require('../node_modules/uint8arraylist/dist/src/index.js');
+var oidfetch_proto = require('../proto/oidfetch_proto.js');
+var cid = require('../node_modules/multiformats/dist/src/cid.js');
+var index$3 = require('../node_modules/@libp2p/autonat/dist/src/index.js');
+var index$2 = require('../node_modules/@libp2p/dcutr/dist/src/index.js');
+var blockBrokers = require('@helia/block-brokers');
+var dcapi = require('./dcapi.js');
+var define = require('./define.js');
+var index$7 = require('../node_modules/@libp2p/circuit-relay-v2/dist/src/transport/index.js');
+
+// http2 type
+class Http2_Type {}
+Object.defineProperty(Http2_Type, "Handshake", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 0x00
+});
+Object.defineProperty(Http2_Type, "Data", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 0x01
+});
+Object.defineProperty(Http2_Type, "ACK", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 0x02
+});
+Object.defineProperty(Http2_Type, "Close", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 0x03
+});
+class BrowserType {}
+Object.defineProperty(BrowserType, "File", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 1
+});
+Object.defineProperty(BrowserType, "ThreadDB", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 2
+});
+const controller = new AbortController();
+const {
+  signal
+} = controller;
+// import {uPnPNAT} from '@libp2p/upnp-nat'
+class DcUtil {
+  constructor(dcChain) {
+    Object.defineProperty(this, "dcChain", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "connectLength", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dcNodeClient", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    }); // 什么类型？dc node 对象，主要用于建立连接
+    Object.defineProperty(this, "defaultPeerId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    }); // 默认 peerId
+    // 连接到所有文件存储节点
+    Object.defineProperty(this, "_connectToObjNodes", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async cid => {
+        const peers = await this.dcChain.getObjNodes(cid);
+        if (!peers) {
+          console.error("peers is null");
+          return [null, null];
+        }
+        const res = await this._connectPeers(peers);
+        return [res, peers];
+      }
+    });
+    Object.defineProperty(this, "connectToPeer", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async peerAddr => {
+        return await this._connectPeers([peerAddr]);
+      }
+    });
+    Object.defineProperty(this, "_connectPeers", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: peerListJson => {
+        return new Promise((reslove, reject) => {
+          const _this = this;
+          const len = peerListJson.length;
+          let num = 0;
+          async function dialNodeAddr(i) {
+            if (!peerListJson[i]) {
+              return;
+            }
+            const [nodeAddr, _] = await _this.dcChain.getDcNodeWebrtcDirectAddr(peerListJson[i]);
+            if (!nodeAddr) {
+              console.error("no nodeAddr return");
+              num++;
+              if (num >= len) {
+                reject("no nodeAddr return");
+              }
+              return;
+            }
+            try {
+              if (_this.dcNodeClient?.libp2p) {
+                const resCon = await _this.dcNodeClient?.libp2p.dial(nodeAddr, {
+                  signal: AbortSignal.timeout(define.dial_timeout)
+                });
+                if (resCon) {
+                  reslove(nodeAddr);
+                } else {
+                  num++;
+                  if (num >= len) {
+                    reject("dial nodeAddr failed");
+                  }
+                }
+              }
+            } catch (error) {
+              if (error && typeof error === "object" && "message" in error) {
+                num++;
+                if (num >= len) {
+                  console.error("dial nodeAddr error,error:%s", error.message);
+                  reject(error.message);
+                }
+              } else {
+                num++;
+                if (num >= len) {
+                  console.error("dial nodeAddr error,error:", error);
+                  reject(error);
+                }
+              }
+            }
+          }
+          // 遍历传进来的promise数组
+          for (let i = 0; i < len; i++) {
+            dialNodeAddr(i);
+          }
+        });
+      }
+    });
+    Object.defineProperty(this, "connectToUserDcPeer", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async account => {
+        const peerAddrs = await this.dcChain.getAccountPeers(account);
+        if (!peerAddrs || peerAddrs.length == 0) {
+          return null;
+        }
+        // 连接节点
+        if (!this.dcNodeClient || !this.dcNodeClient?.libp2p) {
+          return null;
+        }
+        const nodeAddr = await this._connectPeers(peerAddrs);
+        console.log("_connectNodeAddrs nodeAddr:", nodeAddr);
+        if (!nodeAddr) {
+          return null;
+        }
+        const client = new dcapi.Client(this.dcNodeClient?.libp2p, this.dcNodeClient.blockstore, nodeAddr, define.dc_protocol);
+        return client;
+      }
+    });
+    // 连接节点列表
+    Object.defineProperty(this, "connectToUserAllDcPeers", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async account => {
+        const peerAddrs = await this.dcChain.getAccountPeers(account);
+        if (!peerAddrs || peerAddrs.length == 0) {
+          return null;
+        }
+        let clients = [];
+        // 连接节点
+        for (let i = 0; i < peerAddrs.length; i++) {
+          const item = peerAddrs[i];
+          if (item) {
+            try {
+              if (!this.dcNodeClient || !this.dcNodeClient?.libp2p) {
+                return null;
+              }
+              const nodeAddr = await this._connectPeers([item]);
+              console.log("_connectNodeAddrs nodeAddr:", nodeAddr);
+              if (!nodeAddr) {
+                return null;
+              }
+              const client = new dcapi.Client(this.dcNodeClient?.libp2p, this.dcNodeClient.blockstore, nodeAddr, define.dc_protocol);
+              clients.push(client);
+            } catch (error) {
+              console.error("connectToUserAllDcPeers error", error);
+            }
+          }
+        }
+        return clients;
+      }
+    });
+    // 连接节点列表
+    Object.defineProperty(this, "_connectNodeAddrs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: peers => {
+        return new Promise((reslove, reject) => {
+          const _this = this;
+          const len = peers.length;
+          let num = 0;
+          async function dialNodeAddr(i) {
+            if (!peers[i]) {
+              console.log("nodeAddr return");
+              num++;
+              if (num >= len) {
+                reslove(null);
+              }
+              return;
+            }
+            const addrParts = peers[i].split(",");
+            const nodeAddr = multiaddr.multiaddr(addrParts[1]);
+            try {
+              if (_this.dcNodeClient?.libp2p) {
+                const res = await _this.dcNodeClient.libp2p.dial(nodeAddr, {
+                  signal: AbortSignal.timeout(define.dial_timeout)
+                });
+                console.log("nodeAddr try return");
+                console.log(res);
+                if (res) {
+                  reslove(nodeAddr);
+                  return;
+                }
+              }
+              num++;
+              if (num >= len) {
+                reslove(null);
+              }
+            } catch (error) {
+              console.error("nodeAddr catch return", error);
+              num++;
+              if (num >= len) {
+                reslove(null);
+              }
+            }
+          }
+          // 遍历传进来的promise数组
+          for (let i = 0; i < len; i++) {
+            dialNodeAddr(i);
+          }
+        });
+      }
+    });
+    Object.defineProperty(this, "_createHeliaNode", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async () => {
+        console.log("_createHeliaNode=======");
+        const datastore = new datastoreIdb.IDBDatastore("helia-meta");
+        await datastore.open();
+        const blockstore = new blockstoreIdb.IDBBlockstore("helia-blocks");
+        await blockstore.open();
+        // const memoryDatastore = new MemoryDatastore();
+        // 创建或导入私钥
+        let keyPair = await utils.loadKeyPair("ed25519_privateKey");
+        if (!keyPair) {
+          keyPair = await crypto.keys.generateKeyPair("Ed25519");
+          await utils.saveKeyPair("ed25519_privateKey", keyPair);
+        }
+        // libp2p is the networking layer that underpins Helia
+        const libp2p$1 = await libp2p.createLibp2p({
+          privateKey: keyPair,
+          datastore: datastore,
+          transports: [index$6.webRTCDirect(), index$7.circuitRelayTransport(), index$6.webRTC()],
+          //
+          connectionEncrypters: [index$5.noise()],
+          connectionGater: {
+            denyDialMultiaddr: () => false // this is necessary to dial local addresses at all
+          },
+          connectionManager: {
+            maxParallelDials: 30,
+            maxConnections: 30,
+            inboundConnectionThreshold: 30
+          },
+          streamMuxers: [index$4.yamux({
+            maxStreamWindowSize: 256 * 1024,
+            // 流窗口大小
+            maxMessageSize: 16 * 1024,
+            // 消息分片阈值
+            keepAliveInterval: 15000,
+            // 保活检测间隔 (ms)
+            maxInboundStreams: 30,
+            maxOutboundStreams: 50,
+            initialStreamWindowSize: 256 * 1024,
+            enableKeepAlive: true
+          })],
+          services: {
+            // dht: kadDHT({
+            //   // 启用 DHT 加强节点发现
+            //   clientMode: true,
+            // }),
+            autoNAT: index$3.autoNAT(),
+            dcutr: index$2.dcutr(),
+            identify: index$1.identify(),
+            identifyPush: index$1.identifyPush(),
+            ping: index.ping(),
+            autoRelay: components => ({
+              // 使用函数式配置
+              enabled: true,
+              // 通过闭包传递参数
+              maxListeners: 2,
+              peerSource: components.peerStore // 注入依赖组件
+            })
+          },
+          addresses: {
+            listen: ["/webrtc-direct", "/p2p-circuit", "/webrtc"]
+          }
+        });
+        const dcNodeClient = await helia.createHelia({
+          blockBrokers: [blockBrokers.bitswap({
+            maxInboundStreams: 64,
+            maxOutboundStreams: 128
+          })],
+          datastore,
+          blockstore,
+          libp2p: libp2p$1
+        });
+        this.dcNodeClient = dcNodeClient;
+        return dcNodeClient;
+      }
+    });
+    // 获取链接过的peerid
+    Object.defineProperty(this, "_getConnectedPeerId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async () => {
+        if (this.defaultPeerId) {
+          return this.defaultPeerId;
+        } else {
+          const defaultPeerId = localStorage.getItem("defaultPeerId");
+          if (defaultPeerId) {
+            this.defaultPeerId = defaultPeerId;
+            return defaultPeerId;
+          }
+          return "";
+        }
+      }
+    });
+    Object.defineProperty(this, "_getNodeAddr", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async peerId => {
+        let [nodeAddr, _] = await this.dcChain.getDcNodeWebrtcDirectAddr(peerId);
+        if (!nodeAddr) {
+          console.error("no node address found for peer: ", peerId);
+          return;
+        }
+        if (multiaddr.isName(nodeAddr)) {
+          const addrs = await nodeAddr.resolve();
+          nodeAddr = addrs[0] ? addrs[0] : null;
+        }
+        return nodeAddr ? nodeAddr : undefined;
+      }
+    });
+    Object.defineProperty(this, "getDefaultDcNodeAddr", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async () => {
+        const peerId = await this._getConnectedPeerId();
+        if (peerId) {
+          let nodeAddr = await this._getNodeAddr(peerId);
+          if (nodeAddr) {
+            try {
+              const connection = await this.dcNodeClient?.libp2p.dial(nodeAddr, {
+                signal: AbortSignal.timeout(define.dial_timeout)
+              });
+              if (connection) {
+                return nodeAddr;
+              }
+            } catch (error) {}
+          }
+          localStorage.removeItem("defaultPeerId");
+        }
+        // 获取节点上的默认节点列表，随机获取几个，批量连接节点，得到最快的节点
+        const allNodeList = await this.dcChain.getDcNodeList();
+        if (!allNodeList) {
+          return;
+        }
+        // 连接节点，得到最快的节点（随机取几个连接取最快，如果都没有连接上继续随机取）
+        const nodeAddr = await this._getConnectDcNodeList(allNodeList);
+        if (!nodeAddr) {
+          console.error("no node connected");
+          return;
+        }
+        // 保存默认节点
+        const defaultPeerId = nodeAddr.getPeerId();
+        if (defaultPeerId) {
+          localStorage.setItem("defaultPeerId", defaultPeerId.toString());
+        }
+        return nodeAddr;
+      }
+    });
+    Object.defineProperty(this, "_getConnectDcNodeList", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async nodeList => {
+        if (nodeList.length > this.connectLength) {
+          let dcNodeList = this._getRamdomNodeList(nodeList, this.connectLength);
+          const nodeAddr = await this._connectNodeAddrs(dcNodeList);
+          if (!nodeAddr) {
+            // allNodeList 过滤掉dcNodeList
+            const leftNodeList = nodeList.filter(node => dcNodeList.indexOf(node) === -1);
+            return this._getConnectDcNodeList(leftNodeList);
+          }
+          return nodeAddr;
+        } else {
+          let nodeAddr = await this._connectNodeAddrs(nodeList);
+          if (!nodeAddr) {
+            return;
+          }
+          return nodeAddr;
+        }
+      }
+    });
+    Object.defineProperty(this, "_getRamdomNodeList", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: (nodeList, num) => {
+        const len = nodeList.length;
+        const res = [];
+        for (let i = 0; i < num; i++) {
+          const randomIndex = Math.floor(Math.random() * len);
+          res.push(nodeList[randomIndex]);
+        }
+        return res;
+      }
+    });
+    this.dcChain = dcChain;
+    this.connectLength = 5;
+  }
+  //创建主动上报流处理,type:1-文件或文件夹假Cid,2-threaddb threadid,3-threaddb recordid
+  async createTransferStream(libp2p, blockstore, nodeAddr, type, oid) {
+    const nodeConn = await libp2p.dial(nodeAddr, {
+      signal: AbortSignal.timeout(define.dial_timeout)
+    });
+    //判断是否有现成的stream,如果已经存在就直接使用
+    const stream = await nodeConn.newStream("/dc/transfer/1.0.0");
+    const writer = new streamwriter.StreamWriter(stream.sink);
+    const mParts = [];
+    let parsedMessage = null;
+    let data;
+    let handshakeFlag = false;
+    for await (const chunk of this.chunkGenerator(stream)) {
+      if (chunk instanceof index$8.Uint8ArrayList) {
+        data = chunk.subarray();
+      } else {
+        data = chunk;
+      }
+      mParts.push(data);
+      // 合并所有数据块为完整 Uint8Array  
+      const fullMessage = utils.concatenateUint8Arrays(...mParts);
+      parsedMessage = null;
+      parsedMessage = this.parseMessage(fullMessage);
+      if (parsedMessage) {
+        if (parsedMessage.type === 3) {
+          //close
+          break;
+        }
+        if (!handshakeFlag) {
+          // 解析消息
+          const initRequest = oidfetch_proto.oidfetch.pb.InitRequset.decode(parsedMessage.payload);
+          if (!initRequest) {
+            continue;
+          }
+          //mParts 清空
+          mParts.length = 0;
+          //发送数据到服务器
+          const message = new TextEncoder().encode(oid);
+          const initReply = new oidfetch_proto.oidfetch.pb.InitReply({
+            type: type,
+            oid: message
+          });
+          //组装数据
+          const initReplyBytes = oidfetch_proto.oidfetch.pb.InitReply.encode(initReply).finish();
+          const messageData = this.assembleCustomMessage({
+            type: Http2_Type.ACK,
+            version: 1,
+            payload: initReplyBytes
+          });
+          await writer.write(messageData);
+          handshakeFlag = true;
+        } else {
+          // 解析消息
+          const fetchRequest = oidfetch_proto.oidfetch.pb.FetchRequest.decode(parsedMessage.payload);
+          const resCid = new TextDecoder().decode(fetchRequest.cid);
+          //获取resCid对应的block
+          const cid$1 = cid.CID.parse(resCid);
+          // 通过 blockstore 获取该 CID 对应的区块  
+          try {
+            const block = await blockstore.get(cid$1);
+            const fetchReply = new oidfetch_proto.oidfetch.pb.FetchReply({
+              data: block
+            });
+            const fetchReplyBytes = oidfetch_proto.oidfetch.pb.FetchReply.encode(fetchReply).finish();
+            const messageData = this.assembleCustomMessage({
+              type: Http2_Type.ACK,
+              version: 1,
+              payload: fetchReplyBytes
+            });
+            await writer.write(messageData);
+            mParts.length = 0;
+          } catch (error) {
+            console.error('Error retrieving block:', error);
+          }
+        }
+      }
+    }
+    stream.close();
+  }
+  async *chunkGenerator(stream) {
+    const iterator = stream.source[Symbol.asyncIterator]();
+    while (true) {
+      try {
+        const {
+          done,
+          value
+        } = await iterator.next();
+        if (done) break;
+        const res = value instanceof index$8.Uint8ArrayList ? value.subarray() : value;
+        yield res;
+      } catch (err) {
+        console.log('chunkGenerator error:', err);
+      }
+    }
+  }
+  /**
+  * 组装 CustomMessage 数据到 Uint8Array
+  * @param message - CustomMessage 包含消息的基本结构
+  * @returns Uint8Array - 序列化后的数据
+  */
+  assembleCustomMessage(message) {
+    // Step 1: header部分（1字节类型 + 2字节版本号 + 4字节payload长度）  
+    const headerLength = 7; // Header固定长度：1字节Type + 2字节Version + 4字节Payload长度  
+    const payloadLength = message.payload.byteLength;
+    const buffer = new Uint8Array(headerLength + payloadLength);
+    buffer[0] = message.type;
+    buffer[1] = message.version >> 8 & 0xff;
+    buffer[2] = message.version & 0xff;
+    buffer[3] = payloadLength >> 24 & 0xff;
+    buffer[4] = payloadLength >> 16 & 0xff;
+    buffer[5] = payloadLength >> 8 & 0xff;
+    buffer[6] = payloadLength & 0xff;
+    // Step 5: 设置 Payload 数据  
+    buffer.set(message.payload, headerLength);
+    return buffer;
+  }
+  parseMessage(data) {
+    if (data.length < 7) {
+      return null;
+    }
+    // 第 1 字节: 消息类型  
+    const type = data[0];
+    // 第 2 和 3 字节: 版本号（大端序）  
+    const version = data[1] << 8 | data[2]; // 手动处理大端序  
+    // 第 4 至 7 字节: payload 长度（大端序）  
+    const payloadLength = data[3] << 24 | data[4] << 16 | data[5] << 8 | data[6];
+    // 验证数据完整性  
+    if (data.length < 7 + payloadLength) {
+      return null;
+    }
+    // 提取 payload  
+    const payload = data.slice(7, 7 + payloadLength); // 提取负载数据  
+    return {
+      type,
+      version,
+      payload
+    };
+  }
+}
+
+exports.BrowserType = BrowserType;
+exports.DcUtil = DcUtil;
+exports.Http2_Type = Http2_Type;

package/dist/cjs/common/define.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const walletOpenOrgin = typeof globalThis !== "undefined" ? globalThis.walletOpenOrgin : ""; // 用户传入的打开钱包的源;
+const walletOpenVersion = typeof globalThis !== "undefined" ? globalThis.walletOpenVersion : ""; // 钱包版本号;
+let _baseUrl = "";
+let _walletOrigin = "";
+{
+  _baseUrl = "/v0_0_11";
+  _walletOrigin = "https://wallet.dcnetio.com";
+  if (walletOpenOrgin) {
+    _walletOrigin = walletOpenOrgin || "https://wallet.dcnetio.com";
+  }
+  if (walletOpenVersion) {
+    _baseUrl = walletOpenVersion && walletOpenVersion.startsWith("/") ? walletOpenVersion : "/" + walletOpenVersion;
+  }
+}
+const walletOrigin = _walletOrigin;
+const walletUrl = _walletOrigin + _baseUrl; // 钱包地址后面统一改成origin+version
+const walletWindowName = "walletWindow"; // 窗口名称
+const dc_protocol = "/dc/thread/0.0.1";
+const dial_timeout = 1000;
+const keyExpire = 60 * 60 * 24; // setcachekey 过期时间默认一天
+const OffChainOpTimes = 20000; // 链下操作次数
+const OffChainSpaceLimit = 1024 * 1024 * 10; // 评论空间下限10m
+const OffChainOpTimesLimit = 1000; // 链下操作次数下限
+exports.Direction = void 0;
+(function (Direction) {
+  Direction[Direction["Forward"] = 0] = "Forward";
+  Direction[Direction["Reverse"] = 1] = "Reverse";
+})(exports.Direction || (exports.Direction = {}));
+exports.CommentType = void 0;
+(function (CommentType) {
+  /** 普通评论 */
+  CommentType[CommentType["Comment"] = 0] = "Comment";
+  /** 赞 */
+  CommentType[CommentType["Up"] = 1] = "Up";
+  /** 踩 */
+  CommentType[CommentType["Down"] = 2] = "Down";
+  /** 推荐或转发 */
+  CommentType[CommentType["Transfer"] = 3] = "Transfer";
+  /** keyvalue形式的数据 */
+  CommentType[CommentType["KeyValue"] = 4] = "KeyValue";
+})(exports.CommentType || (exports.CommentType = {}));
+
+exports.OffChainOpTimes = OffChainOpTimes;
+exports.OffChainOpTimesLimit = OffChainOpTimesLimit;
+exports.OffChainSpaceLimit = OffChainSpaceLimit;
+exports.dc_protocol = dc_protocol;
+exports.dial_timeout = dial_timeout;
+exports.keyExpire = keyExpire;
+exports.walletOrigin = walletOrigin;
+exports.walletUrl = walletUrl;
+exports.walletWindowName = walletWindowName;