web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/implements/message/manager.js

@@ -0,0 +1,182 @@
+'use strict';
+
+require('../../_virtual/index.js');
+var client = require('./client.js');
+var multiformats = require('multiformats');
+var sha2Browser = require('../../node_modules/multiformats/dist/src/hashes/sha2-browser.js');
+var ed25519 = require('../../common/dc-key/ed25519.js');
+var utils = require('../../util/utils.js');
+var dcnet_proto = require('../../proto/dcnet_proto.js');
+
+// 错误定义
+class DCError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DCError";
+  }
+}
+const Errors = {
+  ErrNoDcPeerConnected: new DCError("no dc peer connected"),
+  ErrGetUserInfoError: new DCError("get user info error"),
+  ErrNoAccountPeerConnected: new DCError("no account peer connected"),
+  ErrNoReceiverPeerConnected: new DCError("no receiver peer connected")
+};
+class MessageManager {
+  constructor(dc, chainUtil, context) {
+    var _this = this;
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "chainUtil", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "sendMsgToUserBox", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async (appId, receiver, msg) => {
+        try {
+          if (!this.context.AccountBackupDc.client) {
+            return [null, Errors.ErrNoAccountPeerConnected];
+          }
+          const receiverPubkey = ed25519.Ed25519PubKey.edPubkeyFromStr(receiver);
+          const sendPublicKey = await this.context.getPublicKey();
+          const userMsg = await this.generateMsqBoxReq(appId, receiverPubkey, msg);
+          // 连接receiver节点
+          let receiverClient = await this.dc.connectToUserDcPeer(receiverPubkey.raw);
+          if (!receiverClient) {
+            return [null, Errors.ErrNoReceiverPeerConnected];
+          }
+          const token = await receiverClient.GetToken(appId, sendPublicKey.string(), payload => {
+            return this.context.sign(payload);
+          });
+          receiverClient.token = token;
+          const messageClient = new client.MessageClient(this.context.AccountBackupDc.client, this.context, receiverClient);
+          const reply = await messageClient.sendMsgToUserBox(userMsg);
+          return [reply, null];
+        } catch (error) {
+          throw error;
+        }
+      }
+    });
+    Object.defineProperty(this, "getMsgFromUserBox", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async function (appId) {
+        let limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+        try {
+          if (!_this.context.AccountBackupDc.client) {
+            return [null, Errors.ErrNoAccountPeerConnected];
+          }
+          const publicKey = await _this.context.getPublicKey();
+          const publickey = publicKey.string();
+          const clients = await _this.dc.connectToUserAllDcPeers(publicKey.raw);
+          if (!clients) {
+            return [null, Errors.ErrNoDcPeerConnected];
+          }
+          let allMsgs = [];
+          for (const client$1 of clients) {
+            if (client$1) {
+              const peerId = client$1.peerAddr.getPeerId() || "";
+              const publicKeyString = _this.context.getPublicKey().string();
+              // 获取token
+              if (!client$1.token) {
+                const token = await client$1.GetToken(appId, publicKeyString, payload => {
+                  return _this.context.sign(payload);
+                });
+                client$1.token = token;
+              }
+              const messageClient = new client.MessageClient(client$1, _this.context);
+              let maxKey = await messageClient.getMaxKeyFromUserBox(appId);
+              const userBoxMaxKeyStr = localStorage.getItem('userBoxMaxKey_' + publicKeyString) || '';
+              let userBoxMaxKey = userBoxMaxKeyStr ? JSON.parse(userBoxMaxKeyStr) : {};
+              if (maxKey) {
+                let preMaxKey = userBoxMaxKey[publickey] || {};
+                preMaxKey[peerId] = maxKey;
+              }
+              let getFlag = true;
+              while (getFlag) {
+                try {
+                  // 获取的maxkey 不等于 之前保存的maxkey
+                  const res = await messageClient.getMsgFromUserBox(appId, maxKey, limit);
+                  const list = res && res["msgs"] ? res["msgs"] : [];
+                  console.log('messageClient.getMsgFromUserBox list', list);
+                  list.map(item => {
+                    if (item && item.messageId) {
+                      allMsgs.push(item);
+                    }
+                  });
+                  if (list.length < limit) {
+                    if (maxKey) {
+                      localStorage.setItem('userBoxMaxKey_' + publicKeyString, JSON.stringify(userBoxMaxKey));
+                    }
+                    getFlag = false;
+                  }
+                } catch (error) {
+                  console.log('messageClient.getMsgFromUserBox error', error);
+                }
+              }
+            }
+          }
+          return [allMsgs, null];
+        } catch (error) {
+          return [null, error];
+        }
+      }
+    });
+    Object.defineProperty(this, "generateMsqBoxReq", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async (appId, receiverPubkey, msg) => {
+        const timeStamp = Date.now() * 1000000; // na timestamp
+        const preId = `${msg}${timeStamp}`;
+        // Create SHA2-256 hash
+        const preIdBytes = new TextEncoder().encode(preId);
+        const hash = await sha2Browser.sha256.digest(preIdBytes);
+        // Create CID version 1 with raw codec
+        const cid = multiformats.CID.create(1, 0x55, hash);
+        const messageIdValue = new TextEncoder().encode(cid.toString());
+        const appIdValue = new TextEncoder().encode(appId);
+        const sendPublicKey = await this.context.getPublicKey();
+        const sendPublicKeyValue = new TextEncoder().encode(sendPublicKey.string());
+        const receiverPubkeyValue = new TextEncoder().encode(receiverPubkey.string());
+        const blockHeight = (await this.chainUtil.getBlockHeight()) || 0;
+        const hValue = utils.uint32ToLittleEndianBytes(blockHeight);
+        const msgValue = new TextEncoder().encode(msg);
+        const encryptMsgValue = await receiverPubkey.encrypt(msgValue);
+        const preSign = new Uint8Array([...messageIdValue, ...receiverPubkeyValue, ...appIdValue, ...hValue, ...encryptMsgValue]);
+        const signature = await this.context.sign(preSign);
+        const userMsg = new dcnet_proto.dcnet.pb.UserMsg({});
+        userMsg.appId = new TextEncoder().encode(appId);
+        userMsg.blockheight = blockHeight;
+        userMsg.encryptMsg = encryptMsgValue;
+        userMsg.messageId = messageIdValue;
+        userMsg.receiverPubkey = receiverPubkeyValue;
+        userMsg.senderPubkey = sendPublicKeyValue;
+        userMsg.signature = signature;
+        return userMsg;
+      }
+    });
+    this.dc = dc;
+    this.chainUtil = chainUtil;
+    this.context = context;
+  }
+}
+
+exports.DCError = DCError;
+exports.Errors = Errors;
+exports.MessageManager = MessageManager;

package/dist/cjs/implements/threaddb/cbor/coding.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var node = require('./node.js');
+var dagCBOR = require('@ipld/dag-cbor');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var dagCBOR__namespace = /*#__PURE__*/_interopNamespaceDefault(dagCBOR);
+
+/**
+ * Encrypts a block's raw data with the given key and wraps it as a DAG-CBOR node
+ *
+ * @param block - The block to encode
+ * @param key - The encryption key
+ * @returns Promise resolving to a Node
+ */
+async function encodeBlock(block, key) {
+  // Encrypt the block's raw data using the provided key
+  const coded = await key.encrypt(block.data());
+  return await node.wrapObject(coded);
+}
+/**
+ * Decrypts a block's raw data with the given key and returns a DAG node
+ *
+ * @param block - The block to decode
+ * @param key - The decryption key
+ * @returns Promise resolving to a Node
+ */
+async function decodeBlock(block, key) {
+  let obj = block;
+  if (typeof block.data === 'function') {
+    obj = dagCBOR__namespace.decode(block.data());
+  } else {
+    try {
+      obj = dagCBOR__namespace.decode(block);
+    } catch (e) {
+      obj = block;
+    }
+  }
+  let encryptData;
+  if (obj instanceof Uint8Array) {
+    encryptData = obj;
+  } else {
+    try {
+      encryptData = dagCBOR__namespace.decode(obj._data);
+    } catch (e) {
+      encryptData = obj._data;
+    }
+  }
+  let decrptData = encryptData;
+  // Decrypt the data using the provided key
+  if (key) {
+    decrptData = await key.decrypt(encryptData);
+  }
+  return node.decode(decrptData);
+}
+
+exports.decodeBlock = decodeBlock;
+exports.encodeBlock = encodeBlock;

package/dist/cjs/implements/threaddb/cbor/event.js

@@ -0,0 +1,257 @@
+'use strict';
+
+var key = require('../common/key.js');
+var dagCBOR = require('@ipld/dag-cbor');
+var coding = require('./coding.js');
+var node = require('./node.js');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var dagCBOR__namespace = /*#__PURE__*/_interopNamespaceDefault(dagCBOR);
+
+/**
+ * 创建一个新事件，包装 body 节点
+ * @param dag DAG 服务
+ * @param body 要封装的节点
+ * @param rkey 加密密钥
+ * @returns 创建的事件
+ */
+async function CreateEvent(bstore, body, rkey) {
+  // 创建随机对称密钥
+  const key$1 = key.SymmetricKey.new();
+  if (!body.rawData) {
+    throw new Error("Node data is undefined");
+  }
+  const bodyBlock = new node.Block(body.rawData(), body.cid());
+  // 使用密钥加密 body
+  const codedBody = await coding.encodeBlock(bodyBlock, key$1);
+  // 序列化密钥
+  const keyb = key$1.bytes();
+  // 创建事件头部
+  const eventHeader = {
+    key: keyb
+  };
+  const header = await node.wrapObject(eventHeader);
+  const codedHeader = await coding.encodeBlock(header, rkey);
+  // 创建事件对象
+  const obj = {
+    body: codedBody.cid(),
+    header: codedHeader.cid()
+  };
+  // 包装事件对象为 CBOR 节点
+  const node$1 = await node.wrapObject(obj);
+  // 添加到 DAG
+  if (bstore) {
+    await bstore.put(node$1.cid(), node$1.data());
+    await bstore.put(codedHeader.cid(), codedHeader.data());
+    await bstore.put(codedBody.cid(), codedBody.data());
+  }
+  // 返回事件
+  return new Event(node$1, obj, new EventHeader(codedHeader, eventHeader), codedBody);
+}
+/**
+ * 将节点解码为事件
+ * @param node 要解码的节点
+ * @returns 解码后的事件
+ */
+async function EventFromNode(eNode) {
+  try {
+    //取出头部
+    const eventObj = eNode;
+    const wrapedRnode = await node.wrapObject(eventObj);
+    const event = new Event(wrapedRnode, eventObj);
+    return event;
+  } catch (err) {
+    throw new Error(`Failed to decode node into event: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+/**
+ * 从记录中获取事件
+ * @param ctx 上下文
+ * @param dag DAG 服务
+ * @param rec 记录
+ * @returns 获取的事件
+ */
+async function EventFromRecord(bstore, rec) {
+  try {
+    const block = await rec.getBlock(bstore);
+    // 检查是否已经是 Event
+    if (block instanceof Event) {
+      return block;
+    }
+    return await EventFromNode(block);
+  } catch (err) {
+    throw new Error(`Failed to get event from record: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+/**
+ * 表示事件的 IPLD 节点
+ */
+class Event {
+  constructor(node, obj, header, body) {
+    Object.defineProperty(this, "_node", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_obj", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_header", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_body", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this._node = node;
+    this._obj = obj;
+    if (header) {
+      this._header = header;
+    }
+    if (body) {
+      this._body = body;
+    }
+  }
+  cid() {
+    return this._node.cid();
+  }
+  headerCID() {
+    return this._obj.header;
+  }
+  async getHeader(bstore, key) {
+    if (!this._header) {
+      const blockData = await bstore.get(this._obj.header);
+      const headerNode = await node.wrapObject(blockData);
+      this._header = new EventHeader(headerNode);
+    }
+    try {
+      if (!this._header.isLoaded() && key) {
+        const decoded = dagCBOR__namespace.decode(this._header.node().data());
+        if (!decoded) {
+          throw new Error("Failed to decode block");
+        }
+        let encryptedData = decoded;
+        try {
+          encryptedData = dagCBOR__namespace.decode(decoded);
+        } catch (e) {}
+        const data = await key.decrypt(encryptedData);
+        const header = dagCBOR__namespace.decode(data);
+        this._header.setObj(header);
+      }
+    } catch (err) {
+      throw new Error(`Failed to decode header: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return this._header;
+  }
+  bodyCID() {
+    return this._obj.body;
+  }
+  async getBody(bstore, key) {
+    let k = null;
+    if (key) {
+      const header = await this.getHeader(bstore, key);
+      k = await header.key();
+    }
+    if (!this._body) {
+      const block = await bstore.get(this._obj.body);
+      this._body = await node.wrapObject(block);
+    }
+    if (!k) {
+      return this._body;
+    } else {
+      return coding.decodeBlock(this._body, k);
+    }
+  }
+  data() {
+    return this._node.data();
+  }
+  links() {
+    return this._node.links();
+  }
+  size() {
+    return this._node.size();
+  }
+}
+/**
+ * 表示事件头部的 IPLD 节点
+ */
+class EventHeader {
+  constructor(node) {
+    let obj = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    Object.defineProperty(this, "_node", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_obj", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this._node = node;
+    this._obj = obj;
+  }
+  isLoaded() {
+    return this._obj !== null;
+  }
+  setObj(obj) {
+    this._obj = obj;
+  }
+  node() {
+    return this._node;
+  }
+  cid() {
+    return this._node.cid();
+  }
+  links() {
+    return this._node.links();
+  }
+  async key() {
+    if (!this._obj) {
+      throw new Error("EventHeader object not loaded");
+    }
+    if (!this._obj.key) {
+      throw new Error("Key is undefined");
+    }
+    return key.SymmetricKey.fromBytes(this._obj.key);
+  }
+  data() {
+    return this._node.data();
+  }
+  size() {
+    return this._node.size();
+  }
+}
+
+exports.CreateEvent = CreateEvent;
+exports.Event = Event;
+exports.EventFromNode = EventFromNode;
+exports.EventFromRecord = EventFromRecord;
+exports.EventHeader = EventHeader;