web-dc-api 0.0.57 → 0.0.59

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

@@ -0,0 +1,476 @@
+'use strict';
+
+var client = require('./client.js');
+var constants = require('../../common/constants.js');
+var manager = require('../comment/manager.js');
+var ed25519 = require('../../common/dc-key/ed25519.js');
+var utils = require('../../util/utils.js');
+var base32 = require('../../node_modules/multiformats/dist/src/bases/base32.js');
+var define = require('../../common/define.js');
+
+//定义Key-Value存储的数据类型
+exports.KeyValueStoreType = void 0;
+(function (KeyValueStoreType) {
+  KeyValueStoreType[KeyValueStoreType["Auth"] = 1] = "Auth";
+  KeyValueStoreType[KeyValueStoreType["Public"] = 2] = "Public";
+})(exports.KeyValueStoreType || (exports.KeyValueStoreType = {}));
+// 错误定义
+class KeyValueError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KeyValueError";
+  }
+}
+const Errors = {
+  ErrNoDcPeerConnected: new KeyValueError("no dc peer connected"),
+  ErrPublicKeyIsNull: new KeyValueError("publickey is null")
+};
+class KeyValueDB {
+  constructor(appId, dbname, themeAuthor, manager) {
+    Object.defineProperty(this, "appId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dbname", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "themeAuthor", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "manager", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.appId = appId;
+    this.dbname = dbname;
+    this.themeAuthor = themeAuthor;
+    this.manager = manager;
+  }
+  //设置键值对
+  async set(key, value) {
+    let indexs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";
+    let vaccount = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "";
+    return this.manager.setKeyValue(this.appId, this.themeAuthor, this.dbname, key, value, indexs, vaccount);
+  }
+  //获取键值对
+  async get(key, writerPubkey, vaccount) {
+    if (!writerPubkey) {
+      writerPubkey = this.themeAuthor;
+    }
+    return this.manager.getValueWithKey(this.appId, this.themeAuthor, this.dbname, writerPubkey, key, vaccount);
+  }
+  //批量获取键值对
+  async getBatch(keys, writerPubkey, vaccount) {
+    if (!writerPubkey) {
+      writerPubkey = this.themeAuthor;
+    }
+    return this.manager.getValuesWithKeys(this.appId, this.themeAuthor, this.dbname, writerPubkey, keys, vaccount);
+  }
+  //通过索引获取键值对
+  async getWithIndex(indexKey, indexValue) {
+    let limit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;
+    let seekKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "";
+    let direction = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : define.Direction.Forward;
+    let offset = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
+    let vaccount = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : "";
+    return this.manager.getWithIndex(this.appId, this.themeAuthor, this.dbname, indexKey, indexValue, seekKey, direction, offset, limit, vaccount);
+  }
+  //配置授权
+  async configAuth(authPubkey, permission, remark, vaccount) {
+    return this.manager.doConfigAuth(this.appId, this.themeAuthor, this.dbname, authPubkey, permission, remark, vaccount);
+  }
+  //获取授权列表
+  async getAuthList(vaccount) {
+    return this.manager.getAuthList(this.appId, this.themeAuthor, this.dbname, vaccount);
+  }
+}
+class KeyValueManager {
+  constructor(dc, chainUtil, context) {
+    Object.defineProperty(this, "dc", {
+      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, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.dc = dc;
+    this.chainUtil = chainUtil;
+    this.context = context;
+  }
+  // 创建Key-Value存储
+  async createStore(appId, theme, space, type) {
+    if (!this.context.publicKey) {
+      return [null, Errors.ErrPublicKeyIsNull];
+    }
+    // Default group to "DCAPP" if empty
+    if (appId === "") {
+      appId = "DCAPP";
+    }
+    // Set minimum space (100M)
+    if (space < 100 << 20) {
+      space = 100 << 20;
+    }
+    // Theme must start with "keyvalue_"
+    if (!theme.startsWith("keyvalue_")) {
+      theme = "keyvalue_" + theme;
+    }
+    // NOTE: There seems to be a logical error in the original code:
+    // It checks if theme ends with "_pub" and returns an error if it does,
+    // but the error message suggests it should end with "_pub".
+    // I'm assuming the condition should check if it doesn't end with "_pub"
+    if (type === exports.KeyValueStoreType.Public) {
+      // Public theme must end with "_pub"
+      if (!theme.endsWith("_pub")) {
+        return [null, new Error("vaCreateStoreTheme failed, public theme must end with '_pub'")];
+      }
+    }
+    try {
+      // Assuming AddThemeObjDeal is implemented elsewhere
+      const commentManager = new manager.CommentManager(this.context);
+      const res = await commentManager.addThemeObj(appId, theme, constants.OpenFlag.AUTH, space || 50 * 1024 * 1024 // 50M
+      );
+      if (res[0] !== 0 || res[1] !== null) {
+        return [null, new Error(`vaCreateStoreTheme failed, resFlag: ${res}`)];
+      }
+      // Create KeyValueDB instance
+      const keyValueDB = new KeyValueDB(appId, theme, this.context.publicKey.string(), this);
+      return [keyValueDB, null];
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  async getKeyValueDB(appId, theme, ThemeAuthor) {
+    const commentManager = new manager.CommentManager(this.context);
+    // Ensure theme starts with "keyvalue_"
+    if (!theme.startsWith("keyvalue_")) {
+      theme = "keyvalue_" + theme;
+    }
+    //先判断主题是否存在,不存在就报错
+    const [flag, err] = await commentManager.isThemeExist(appId, theme, ThemeAuthor);
+    if (err) {
+      return [null, err];
+    }
+    if (!flag) {
+      return [null, new Error(`Theme ${theme} does not exist for appId ${appId}`)];
+    }
+    const keyValueDB = new KeyValueDB(appId, theme, ThemeAuthor, this);
+    return [keyValueDB, null];
+  }
+  async doConfigAuth(appId, themeAuthor, theme, authPubkey, permission, remark, vaccount) {
+    if (!this.context.publicKey) {
+      return [null, Errors.ErrPublicKeyIsNull];
+    }
+    if (!theme.startsWith("keyvalue_")) {
+      theme = "keyvalue_" + theme;
+    }
+    if (!theme.endsWith("_authlist")) {
+      theme = theme + "_authlist";
+    }
+    const userPubkey = this.context.getPublicKey();
+    let userPubkeyStr = userPubkey.string();
+    let client$1 = this.context.AccountBackupDc?.client || null;
+    if (!client$1) {
+      client$1 = await this.dc.connectToUserDcPeer(this.context.publicKey.raw);
+    }
+    if (client$1 === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.peerAddr === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.token == "") {
+      await client$1.GetToken(appId, this.context.publicKey.string(), this.context.sign);
+    }
+    const themeAuthorPubkey = ed25519.Ed25519PubKey.edPubkeyFromStr(themeAuthor);
+    let pubkeyFlag = true;
+    let forPubkey = null;
+    try {
+      forPubkey = ed25519.Ed25519PubKey.edPubkeyFromStr(authPubkey);
+    } catch (error) {
+      pubkeyFlag = false;
+    }
+    let forPubkeyHex;
+    if (pubkeyFlag && forPubkey !== null) {
+      forPubkeyHex = forPubkey.string();
+    } else {
+      forPubkeyHex = authPubkey;
+    }
+    const content = `${forPubkeyHex}:${permission}:${remark}`;
+    // Generate contentCid (sha256 of content)
+    const commentUint8 = new TextEncoder().encode(content);
+    const contentHash = await utils.sha256(commentUint8);
+    const contentCid = base32.base32.encode(contentHash);
+    // Get blockchain height
+    let blockHeight;
+    try {
+      blockHeight = (await this.chainUtil.getBlockHeight()) || 0;
+    } catch (error) {
+      return [null, new Error("ErrGetBlockHeightFail")];
+    }
+    const contentSize = commentUint8.length;
+    // Create binary representation of blockHeight (little endian)
+    const hValue = utils.uint32ToLittleEndianBytes(blockHeight ? blockHeight : 0);
+    // Create binary representation of type (little endian)
+    const typeValue = utils.uint32ToLittleEndianBytes(define.CommentType.Comment);
+    // sign(Theme+appId+objAuthor+blockheight+contentCid)
+    const themeValue = new TextEncoder().encode(theme);
+    const appIdValue = new TextEncoder().encode(appId);
+    const themeAuthorValue = new TextEncoder().encode(themeAuthorPubkey.string());
+    const contentCidValue = new TextEncoder().encode(contentCid);
+    let preSign = new Uint8Array([...themeValue, ...appIdValue, ...themeAuthorValue, ...hValue, ...contentCidValue, ...typeValue]);
+    const signature = await this.context.sign(preSign);
+    const keyValueClient = new client.KeyValueClient(client$1, this.context);
+    try {
+      const res = await keyValueClient.configThemeObjAuth(theme, appId, themeAuthor, blockHeight, userPubkeyStr, contentCid, content, contentSize, define.CommentType.Comment, signature, vaccount);
+      if (res !== 0) {
+        return [res, new Error(`configThemeObjAuth fail, resFlag: ${res}`)];
+      } else {
+        return [0, null];
+      }
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  async getAuthList(appId, themeAuthor, theme, vaccount) {
+    if (!theme.startsWith("keyvalue_")) {
+      theme = "keyvalue_" + theme;
+    }
+    if (!theme.endsWith("_authlist")) {
+      theme = theme + "_authlist";
+    }
+    let seekKey = "";
+    let originAuthList = [];
+    let authList = [];
+    try {
+      while (true) {
+        const commentManager = new manager.CommentManager(this.context);
+        const res = await commentManager.getThemeComments(appId, theme, themeAuthor, 0, define.Direction.Forward, 0, 1000, seekKey || "", vaccount);
+        if (res[0] && res[0].length == 0) {
+          break;
+        }
+        const resList = res[0];
+        if (!resList || resList.length == 0) {
+          break;
+        }
+        for (let i = 0; i < resList.length; i++) {
+          originAuthList.push(resList[i]);
+          const content = resList[i].comment;
+          const parts = content.split(":");
+          if (parts.length < 2) {
+            continue;
+          }
+          const authPubkey = parts[0];
+          const permission = parseInt(parts[1]);
+          const remark = content.substring(parts[0].length + 2);
+          authList.push({
+            pubkey: authPubkey,
+            permission: permission,
+            remark: remark
+          });
+        }
+        if (resList.length < 1000) {
+          break;
+        }
+        seekKey = `${resList[resList.length - 1].blockheight}/${resList[resList.length - 1].commentCid}`;
+      }
+    } catch (error) {
+      return [authList, originAuthList, error];
+    }
+    return [authList, originAuthList, null];
+  }
+  async setKeyValue(appId, themeAuthor, theme, key, value, indexs,
+  //索引列表,格式为key1:value1$$$key2:value2
+  vaccount) {
+    if (!this.context.publicKey) {
+      return [null, Errors.ErrPublicKeyIsNull];
+    }
+    if (!theme.startsWith("keyvalue_")) {
+      theme = "keyvalue_" + theme;
+    }
+    const userPubkey = this.context.getPublicKey();
+    let userPubkeyStr = userPubkey.string();
+    let client$1 = this.context.AccountBackupDc?.client || null;
+    if (!client$1) {
+      client$1 = await this.dc.connectToUserDcPeer(this.context.publicKey.raw);
+    }
+    if (client$1 === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.peerAddr === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.token == "") {
+      await client$1.GetToken(appId, this.context.publicKey.string(), this.context.sign);
+    }
+    let content = `${key}:${value}`;
+    if (indexs != "") {
+      content = `$$i_start$$${indexs}$$i_end$$${content}`;
+    }
+    const contentUint8 = new TextEncoder().encode(content);
+    const contenthash = await utils.sha256(contentUint8);
+    const contentCidBase32 = base32.base32.encode(contenthash);
+    const contentSize = contentUint8.length;
+    const blockHeight = (await this.chainUtil.getBlockHeight()) || 0;
+    const hValue = utils.uint32ToLittleEndianBytes(blockHeight ? blockHeight : 0);
+    const themeValue = new TextEncoder().encode(theme);
+    const themeAuthorValue = new TextEncoder().encode(themeAuthor);
+    const appIdValue = new TextEncoder().encode(appId);
+    const contentCidValue = new TextEncoder().encode(contentCidBase32);
+    const typeValue = utils.uint32ToLittleEndianBytes(define.CommentType.KeyValue);
+    const preSign = new Uint8Array([...themeValue, ...appIdValue, ...themeAuthorValue, ...hValue, ...contentCidValue, ...typeValue]);
+    const signature = await this.context.sign(preSign);
+    const keyValueClient = new client.KeyValueClient(client$1, this.context);
+    try {
+      const res = await keyValueClient.setKeyValue(theme, appId, themeAuthor, blockHeight, userPubkeyStr, contentCidBase32, content, contentSize, define.CommentType.KeyValue, signature, vaccount);
+      if (res !== 0) {
+        return [null, new Error(`setKeyValue fail, resFlag:${res}`)];
+      }
+      return [true, null];
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  async getValueWithKey(appId, themeAuthor, theme, writerPubkey, key, vaccount) {
+    if (!this.context.publicKey) {
+      return [null, Errors.ErrPublicKeyIsNull];
+    }
+    if (!theme.startsWith("keyvalue_")) {
+      theme = "keyvalue_" + theme;
+    }
+    let client$1 = this.context.AccountBackupDc.client || null;
+    if (themeAuthor != this.context.publicKey.string()) {
+      //查询他人主题评论
+      const authorPublicKey = ed25519.Ed25519PubKey.edPubkeyFromStr(themeAuthor);
+      client$1 = await this.dc.connectToUserDcPeer(authorPublicKey.raw);
+      if (!client$1) {
+        return [null, Errors.ErrNoDcPeerConnected];
+      }
+    }
+    if (client$1 === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.peerAddr === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.token == "") {
+      await client$1.GetToken(appId, this.context.publicKey.string(), this.context.sign);
+    }
+    const keyValueClient = new client.KeyValueClient(client$1, this.context);
+    try {
+      const res = await keyValueClient.getValueWithKey(theme, appId, themeAuthor, writerPubkey, key, vaccount);
+      if (res == null) {
+        return [null, new Error(`vaGetValueWithKeyForVAccount fail, resFlag:${res}`)];
+      }
+      const keyValue = new TextDecoder().decode(res);
+      return [keyValue, null];
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  async getValuesWithKeys(appId, themeAuthor, theme, writerPubkey, keys, vaccount) {
+    if (!this.context.publicKey) {
+      return [null, Errors.ErrPublicKeyIsNull];
+    }
+    if (!theme.startsWith("keyvalue_")) {
+      theme = "keyvalue_" + theme;
+    }
+    let client$1 = this.context.AccountBackupDc.client || null;
+    if (themeAuthor != this.context.publicKey.string()) {
+      //查询他人主题评论
+      const authorPublicKey = ed25519.Ed25519PubKey.edPubkeyFromStr(themeAuthor);
+      client$1 = await this.dc.connectToUserDcPeer(authorPublicKey.raw);
+      if (!client$1) {
+        return [null, Errors.ErrNoDcPeerConnected];
+      }
+    }
+    if (client$1 === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.peerAddr === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.token == "") {
+      await client$1.GetToken(appId, this.context.publicKey.string(), this.context.sign);
+    }
+    const keyValueClient = new client.KeyValueClient(client$1, this.context);
+    try {
+      const res = await keyValueClient.getValuesWithKeys(theme, appId, themeAuthor, writerPubkey, keys, vaccount);
+      if (res == null) {
+        return [null, new Error(`vaGetValuesWithKeysForVAccount fail, resFlag:${res}`)];
+      }
+      const keyValues = new TextDecoder().decode(res);
+      return [keyValues, null];
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  async getWithIndex(appId, themeAuthor, theme, indexKey, indexValue, seekKey) {
+    let direction = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : define.Direction.Forward;
+    let offset = arguments.length > 7 ? arguments[7] : undefined;
+    let limit = arguments.length > 8 ? arguments[8] : undefined;
+    let vaccount = arguments.length > 9 ? arguments[9] : undefined;
+    if (!this.context.publicKey) {
+      return [null, Errors.ErrPublicKeyIsNull];
+    }
+    if (!theme.startsWith("keyvalue_")) {
+      theme = "keyvalue_" + theme;
+    }
+    let client$1 = this.context.AccountBackupDc.client || null;
+    if (themeAuthor != this.context.publicKey.string()) {
+      //查询他人主题评论
+      const authorPublicKey = ed25519.Ed25519PubKey.edPubkeyFromStr(themeAuthor);
+      client$1 = await this.dc.connectToUserDcPeer(authorPublicKey.raw);
+      if (!client$1) {
+        return [null, Errors.ErrNoDcPeerConnected];
+      }
+      //获取token
+      await client$1.GetToken(appId, this.context.publicKey.string(), this.context.sign);
+    }
+    if (client$1 === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.peerAddr === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client$1.token == "") {
+      await client$1.GetToken(appId, this.context.publicKey.string(), this.context.sign);
+    }
+    const keyValueClient = new client.KeyValueClient(client$1, this.context);
+    try {
+      const res = await keyValueClient.getValuesWithIndex(appId, themeAuthor, theme, indexKey, indexValue, seekKey, direction, offset, limit, vaccount);
+      if (res == null) {
+        return [null, new Error(`vaGetValuesWithKeysForVAccount fail, resFlag:${res}`)];
+      }
+      const keyValues = new TextDecoder().decode(res);
+      return [keyValues, null];
+    } catch (error) {
+      return [null, error];
+    }
+  }
+}
+
+exports.Errors = Errors;
+exports.KeyValueDB = KeyValueDB;
+exports.KeyValueError = KeyValueError;
+exports.KeyValueManager = KeyValueManager;

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

@@ -0,0 +1,177 @@
+'use strict';
+
+var grpcLibp2pClient = require('grpc-libp2p-client');
+var dcnet_proto = require('../../proto/dcnet_proto.js');
+var error = require('../../common/error.js');
+var toString = require('../../node_modules/uint8arrays/dist/src/to-string.js');
+
+class MessageClient {
+  constructor(dcClient, context, receiverClient) {
+    Object.defineProperty(this, "client", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "receiverClient", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "sendMsgToUserBox", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async userMsg => {
+        const peerId = this.client.peerAddr.getPeerId();
+        if (!peerId) {
+          throw new Error("peerId is undefined");
+        }
+        if (!this.receiverClient) {
+          throw new Error("receiverClient is undefined");
+        }
+        // 用户节点auth签名
+        const authSignature = await this.getToUserBoxAuth(userMsg.signature);
+        // let peerPubkey = await extractPublicKeyFromPeerId(peerIdFromString(peerId))
+        // const verify  = peerPubkey.verify(signature, authSignature)
+        const message = new dcnet_proto.dcnet.pb.SendMsgToUserBoxRequest({});
+        message.msg = userMsg;
+        message.AuthSignature = authSignature;
+        message.PeerId = new TextEncoder().encode(peerId.toString());
+        const messageBytes = dcnet_proto.dcnet.pb.SendMsgToUserBoxRequest.encode(message).finish();
+        const grpcClient = new grpcLibp2pClient.Libp2pGrpcClient(this.receiverClient.p2pNode, this.receiverClient.peerAddr, this.receiverClient.token, this.receiverClient.protocol);
+        try {
+          const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/SendMsgToUserBox", messageBytes, 30000);
+          console.log("SendMsgToUserBox responseData", responseData);
+          const decoded = dcnet_proto.dcnet.pb.SendMsgToUserBoxReply.decode(responseData);
+          console.log("SendMsgToUserBox decoded", decoded);
+          return decoded.flag;
+        } catch (error$1) {
+          if (error$1.message.indexOf(error.Errors.INVALID_TOKEN.message) != -1) {
+            // try to get token
+            const token = await this.receiverClient.GetToken(this.context.appInfo.appId || '', this.context.getPublicKey().string(), payload => {
+              return this.context.sign(payload);
+            });
+            if (!token) {
+              throw new Error(error.Errors.INVALID_TOKEN.message);
+            }
+            const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/SendMsgToUserBox", messageBytes, 30000);
+            console.log("SendMsgToUserBox responseData", responseData);
+            const decoded = dcnet_proto.dcnet.pb.SendMsgToUserBoxReply.decode(responseData);
+            console.log("SendMsgToUserBox decoded", decoded);
+            return decoded.flag;
+          }
+          console.error("SendMsgToUserBox error:", error$1);
+          throw error$1;
+        }
+      }
+    });
+    Object.defineProperty(this, "getToUserBoxAuth", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async signature => {
+        const message = new dcnet_proto.dcnet.pb.GetToUserBoxAuthRequest({});
+        message.msgSignature = signature;
+        const messageBytes = dcnet_proto.dcnet.pb.GetToUserBoxAuthRequest.encode(message).finish();
+        const grpcClient = new grpcLibp2pClient.Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+        try {
+          const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/GetToUserBoxAuth", messageBytes, 30000);
+          console.log("GetToUserBoxAuth responseData", responseData);
+          const decoded = dcnet_proto.dcnet.pb.GetToUserBoxAuthReply.decode(responseData);
+          console.log("GetToUserBoxAuth decoded", decoded);
+          return decoded.signature;
+        } catch (error$1) {
+          if (error$1.message.indexOf(error.Errors.INVALID_TOKEN.message) != -1) {
+            // try to get token
+            const token = await this.client.GetToken(this.context.appInfo.appId || '', this.context.getPublicKey().string(), payload => {
+              return this.context.sign(payload);
+            });
+            if (!token) {
+              throw new Error(error.Errors.INVALID_TOKEN.message);
+            }
+            const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/GetToUserBoxAuth", messageBytes, 30000);
+            console.log("GetToUserBoxAuth responseData", responseData);
+            const decoded = dcnet_proto.dcnet.pb.GetToUserBoxAuthReply.decode(responseData);
+            console.log("GetToUserBoxAuth decoded", decoded);
+            return decoded.signature;
+          }
+          console.error("GetToUserBoxAuth error:", error$1);
+          throw error$1;
+        }
+      }
+    });
+    this.client = dcClient;
+    this.context = context;
+    this.receiverClient = receiverClient;
+  }
+  async getMaxKeyFromUserBox(appId) {
+    const message = new dcnet_proto.dcnet.pb.GetMaxKeyFromUserBoxRequest();
+    message.appId = new TextEncoder().encode(appId);
+    const messageBytes = dcnet_proto.dcnet.pb.GetMaxKeyFromUserBoxRequest.encode(message).finish();
+    try {
+      const grpcClient = new grpcLibp2pClient.Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+      const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/GetMaxKeyFromUserBox", messageBytes, 30000);
+      const decoded = dcnet_proto.dcnet.pb.GetMaxKeyFromUserBoxReply.decode(responseData);
+      return decoded.maxkey ? toString.toString(decoded.maxkey) : '';
+    } catch (error$1) {
+      if (error$1.message.indexOf(error.Errors.INVALID_TOKEN.message) != -1) {
+        // try to get token
+        const token = await this.client.GetToken(appId, this.context.getPublicKey().string(), payload => {
+          return this.context.sign(payload);
+        });
+        if (!token) {
+          throw new Error(error.Errors.INVALID_TOKEN.message);
+        }
+        const grpcClient = new grpcLibp2pClient.Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+        const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/GetMaxKeyFromUserBox", messageBytes, 30000);
+        const decoded = dcnet_proto.dcnet.pb.GetMaxKeyFromUserBoxReply.decode(responseData);
+        return decoded.maxkey ? toString.toString(decoded.maxkey) : '';
+      }
+      if (error$1.message.indexOf('datastore: key not found') != -1) {
+        return '';
+      }
+      console.error("GetMaxKeyFromUserBox error:", error$1);
+      throw error$1;
+    }
+  }
+  async getMsgFromUserBox(appId, seekKey, limit) {
+    const message = new dcnet_proto.dcnet.pb.GetMsgFromUserBoxRequest();
+    message.appId = new TextEncoder().encode(appId);
+    message.blockheight = 0;
+    message.seekKey = new TextEncoder().encode(seekKey);
+    message.limit = limit;
+    const messageBytes = dcnet_proto.dcnet.pb.GetMsgFromUserBoxRequest.encode(message).finish();
+    try {
+      const grpcClient = new grpcLibp2pClient.Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+      const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/GetMsgFromUserBox", messageBytes, 30000);
+      const decoded = dcnet_proto.dcnet.pb.GetMsgFromUserBoxReply.decode(responseData);
+      return decoded.toJSON();
+    } catch (error$1) {
+      if (error$1.message.indexOf(error.Errors.INVALID_TOKEN.message) != -1) {
+        // try to get token
+        const token = await this.client.GetToken(appId, this.context.getPublicKey().string(), payload => {
+          return this.context.sign(payload);
+        });
+        if (!token) {
+          throw new Error(error.Errors.INVALID_TOKEN.message);
+        }
+        const grpcClient = new grpcLibp2pClient.Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+        const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/getMsgFromUserBox", messageBytes, 30000);
+        const decoded = dcnet_proto.dcnet.pb.GetMsgFromUserBoxReply.decode(responseData);
+        return decoded.toJSON();
+      }
+      console.error("getMsgFromUserBox error:", error$1);
+      throw error$1;
+    }
+  }
+}
+
+exports.MessageClient = MessageClient;