web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/implements/threaddb/pb/proto-custom-types.js

@@ -0,0 +1,174 @@
+'use strict';
+
+var multiaddr = require('@multiformats/multiaddr');
+var cid = require('../../../node_modules/multiformats/dist/src/cid.js');
+var crypto = require('@libp2p/crypto');
+var key = require('../common/key.js');
+var ThreadID = require('@textile/threads-id');
+var peerId = require('@libp2p/peer-id');
+var digest = require('../../../node_modules/multiformats/dist/src/hashes/digest.js');
+
+// proto-custom-types.ts  
+// Peer ID ===================================================================  
+class PeerIDConverter {
+  static fromBytes(ibytes) {
+    try {
+      const multihash = digest.decode(ibytes);
+      const peerID = peerId.peerIdFromMultihash(multihash);
+      if (peerID == null) {
+        throw new Error('Invalid Peer ID');
+      }
+      return peerID;
+    } catch (err) {
+      throw new Error('Invalid Peer ID');
+    }
+  }
+  static toBytes(id) {
+    const peerID = peerId.peerIdFromString(id);
+    if (peerID == null) {
+      throw new Error('Invalid Peer ID');
+    }
+    const peerIDBytes = peerID.toMultihash().bytes;
+    return peerIDBytes;
+  }
+}
+// Multiaddr =================================================================  
+class MultiaddrConverter {
+  static fromBytes(bytes) {
+    try {
+      return multiaddr.multiaddr(bytes);
+    } catch {
+      throw new Error('Invalid multiaddr bytes');
+    }
+  }
+  static toBytes(addr) {
+    return addr.bytes;
+  }
+  /**
+    * Convert from protobuf address info array to Multiaddr array
+    *
+    * @param addrs Array of protobuf address info objects
+    * @returns Array of valid multiaddrs
+    */
+  static addrsFromProtobuf(addrs) {
+    const out = [];
+    for (const addr of addrs) {
+      try {
+        const a = multiaddr.multiaddr(addr);
+        out.push(a);
+      } catch (err) {
+        // Skip invalid addresses
+        continue;
+      }
+    }
+    return out;
+  }
+  /**
+    * Convert from Multiaddr array to protobuf address info array
+    *
+    * @param addrs Array of multiaddrs
+    * @returns Array of protobuf address info objects
+    */
+  static addrsToProtobuf(addrs) {
+    const out = [];
+    for (const addr of addrs) {
+      out.push(addr.bytes);
+    }
+    return out;
+  }
+}
+// CID =======================================================================  
+class CidConverter {
+  static fromBytes(bytes) {
+    try {
+      return cid.CID.decode(bytes);
+    } catch {
+      return cid.CID.parse('bafkqaaa'); // Undefined CID  
+    }
+  }
+  static toBytes(c) {
+    if (c == null) {
+      return new Uint8Array(); // Undefined CID  
+    }
+    return c.bytes;
+  }
+}
+// Thread ID =================================================================  
+class ThreadIDConverter {
+  static fromBytes(bytes) {
+    const id = ThreadID.ThreadID.fromBytes(bytes).toString();
+    return id;
+  }
+  static toBytes(id) {
+    const threadID = ThreadID.ThreadID.fromString(id);
+    return threadID.toBytes();
+  }
+}
+// Cryptographic Keys ========================================================  
+class KeyConverter {
+  // Public Key  
+  static async publicFromBytes(bytes) {
+    try {
+      return crypto.keys.publicKeyFromProtobuf(bytes);
+    } catch {
+      throw new Error('Invalid public key');
+    }
+  }
+  // Private Key  
+  static async privateFromBytes(bytes) {
+    try {
+      return crypto.keys.privateKeyFromProtobuf(bytes);
+    } catch {
+      throw new Error('Invalid private key');
+    }
+  }
+  static async toBytes(key) {
+    try {
+      return crypto.keys.privateKeyToProtobuf(key);
+    } catch {
+      throw new Error('Invalid private key');
+    }
+  }
+  static async publicToBytes(key) {
+    try {
+      return crypto.keys.publicKeyToProtobuf(key);
+    } catch {
+      throw new Error('Invalid public key');
+    }
+  }
+}
+// ProtoKey is a custom type used to serialize and deserialize raw keys into the symmetric.Key type, and back.
+class ProtoKeyConverter {
+  static fromBytes(bytes) {
+    const key$1 = key.Key.fromBytes(bytes);
+    return key$1.toString();
+  }
+  static toBytes(pkey) {
+    const key$1 = key.Key.fromString(pkey);
+    return key$1.toBytes();
+  }
+}
+// Example Usage =============================================================  
+/*
+// 在另一个文件中导入使用：
+import {
+  PeerIDConverter,
+  MultiaddrConverter,
+  CidConverter,
+  ThreadIDConverter,
+  KeyConverter,
+  json
+} from './proto-custom-types'
+
+// 转换PeerID
+const peerBytes = new TextEncoder().encode('QmPNgojgxaxfLh2dfJXPs6f8qHgLueL5t7Yzoe6qkHkJXZ')
+const peerId = PeerIDConverter.fromBytes(peerBytes)
+const restoredBytes = PeerIDConverter.toBytes(peerId)
+*/
+
+exports.CidConverter = CidConverter;
+exports.KeyConverter = KeyConverter;
+exports.MultiaddrConverter = MultiaddrConverter;
+exports.PeerIDConverter = PeerIDConverter;
+exports.ProtoKeyConverter = ProtoKeyConverter;
+exports.ThreadIDConverter = ThreadIDConverter;

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

@@ -0,0 +1,57 @@
+'use strict';
+
+var grpcLibp2pClient = require('grpc-libp2p-client');
+var dcnet_proto = require('../../proto/dcnet_proto.js');
+
+class UtilClient {
+  constructor(dcClient) {
+    Object.defineProperty(this, "client", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.client = dcClient;
+  }
+  /**
+   * 设置应用信息
+   * @param context DCContext 上下文对象
+   * @param threadId 数据库ID
+   * @param rk 读取密钥,主要用来加解密真正的数据
+   * @param sk 服务密钥,主要用来处理传输过程加解密
+   * @param remark 备注信息
+   * @returns Promise resolving when operation completes
+   */
+  async setAppInfo(appId, owner, rewarder, domain, blockHeight, peerId, fid, signature) {
+    if (this.client.p2pNode == null) {
+      throw new Error("p2pNode is null");
+    }
+    try {
+      // Create gRPC client
+      const grpcClient = new grpcLibp2pClient.Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+      // Create request message
+      const message = new dcnet_proto.dcnet.pb.SetAppInfoRequest();
+      message.appId = appId;
+      message.ownerAccount = owner;
+      message.rewardAccount = rewarder;
+      message.domain = domain;
+      message.blockheight = blockHeight;
+      message.peerid = new TextEncoder().encode(peerId);
+      message.fid = new TextEncoder().encode(fid);
+      message.signature = signature;
+      const messageBytes = dcnet_proto.dcnet.pb.SetAppInfoRequest.encode(message).finish();
+      try {
+        // Make RPC call
+        await grpcClient.unaryCall("/dcnet.pb.Service/SetAppInfo", messageBytes, 30000);
+        return;
+      } catch (error) {
+        throw error;
+      }
+    } catch (error) {
+      console.error("设置APP信息失败:", error);
+      throw error;
+    }
+  }
+}
+
+exports.UtilClient = UtilClient;

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

@@ -0,0 +1,118 @@
+'use strict';
+
+var client = require('./client.js');
+var utils$1 = require('../../util/utils.js');
+var ed25519 = require('../../common/dc-key/ed25519.js');
+var error = require('../../common/error.js');
+var utils = require('../../node_modules/@noble/curves/esm/abstract/utils.js');
+
+class UtilManager {
+  constructor(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, "connectedDc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.connectedDc = context.connectedDc;
+    this.dc = context.dcutil;
+    this.chainUtil = context.dcChain;
+    this.context = context;
+  }
+  /**
+   * 设置应用信息
+   * @param appId 应用ID
+   * @param domain 应用域名
+   * @param owner 应用所有者公钥
+   * @param rewarder 应用奖励者公钥
+   * @returns 用户默认数据库信息
+   */
+  async setAppInfo(appId, domain, owner, rewarder) {
+    let fid = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : "";
+    if (!this.context.publicKey || !this.context.ethAddress) {
+      throw error.Errors.NO_USER_INFO;
+    }
+    if (!this.connectedDc.client) {
+      throw error.Errors.NO_DC_PEER_CONNECTED;
+    }
+    if (!this.connectedDc.nodeAddr) {
+      throw error.Errors.NO_DC_PEER_CONNECTED;
+    }
+    const blockHeight = await this.chainUtil?.getBlockHeight();
+    if (blockHeight === undefined) {
+      throw error.Errors.FAIL_TO_GET_BLOCKHEIGHT;
+    }
+    let ownerAccount = this.context.publicKey.bytes();
+    if (owner && owner.length > 10) {
+      ownerAccount = ed25519.Ed25519PubKey.unmarshalString(owner).bytes();
+    }
+    let rewardAccount = utils.hexToBytes(this.context.ethAddress.slice(2));
+    if (rewarder && rewarder.length > 10) {
+      rewardAccount = utils.hexToBytes(rewarder.slice(2));
+    }
+    if (this.connectedDc.client.token == "") {
+      const token = await this.connectedDc.client.GetToken(this.context.appInfo.appId || "", this.context.publicKey.string(), async payload => {
+        return this.context.sign(payload);
+      });
+      if (!token) {
+        throw error.Errors.FAIL_TO_GET_TOKEN;
+      }
+    }
+    const utilClient = new client.UtilClient(this.connectedDc.client);
+    const serverPidStr = this.connectedDc.nodeAddr.getPeerId() || "";
+    const serverPidBytes = new TextEncoder().encode(serverPidStr);
+    const appIdBytes = new TextEncoder().encode(appId);
+    const domainBytes = new TextEncoder().encode(domain);
+    // 生成签名数据
+    const hvalue = utils$1.uint32ToLittleEndianBytes(blockHeight);
+    const preSign = new Uint8Array(appIdBytes.length + domainBytes.length + ownerAccount.length + rewardAccount.length + hvalue.length + serverPidBytes.length + fid.length);
+    let offset = 0;
+    preSign.set(appIdBytes, offset);
+    offset += appIdBytes.length;
+    preSign.set(ownerAccount, offset);
+    offset += ownerAccount.length;
+    preSign.set(rewardAccount, offset);
+    offset += rewardAccount.length;
+    preSign.set(domainBytes, offset);
+    offset += domainBytes.length;
+    preSign.set(hvalue, offset);
+    offset += hvalue.length;
+    preSign.set(serverPidBytes, offset);
+    offset += serverPidBytes.length;
+    preSign.set(new TextEncoder().encode(fid), offset);
+    // 使用私钥签名
+    const signature = await this.context.sign(preSign);
+    await utilClient.setAppInfo(appIdBytes, ownerAccount, rewardAccount, domainBytes, blockHeight, serverPidStr, fid, signature);
+    return;
+  }
+  async getAppInfo(appId) {
+    if (!this.connectedDc.client) {
+      throw error.Errors.NO_DC_PEER_CONNECTED;
+    }
+    if (!this.chainUtil) {
+      throw error.Errors.NO_CHAIN_UTIL;
+    }
+    const appInfo = await this.chainUtil.getAPPInfo(appId);
+    return appInfo;
+  }
+}
+
+exports.UtilManager = UtilManager;