web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/common/dc-key/ed25519.js

@@ -0,0 +1,300 @@
+'use strict';
+
+var ed25519 = require('../../node_modules/@noble/curves/esm/ed25519.js');
+var protobuf = require('protobufjs');
+var identity = require('../../node_modules/multiformats/dist/src/hashes/identity.js');
+var cid = require('../../node_modules/multiformats/dist/src/cid.js');
+var base58 = require('../../node_modules/multiformats/dist/src/bases/base58.js');
+var base32 = require('../../node_modules/multiformats/dist/src/bases/base32.js');
+var utils = require('../../node_modules/@noble/hashes/esm/utils.js');
+var curve25519Encryption = require('../../util/curve25519Encryption.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 protobuf__namespace = /*#__PURE__*/_interopNamespaceDefault(protobuf);
+
+var keyType;
+(function (keyType) {
+  keyType[keyType["RSA"] = 0] = "RSA";
+  keyType[keyType["Ed25519"] = 1] = "Ed25519";
+  keyType[keyType["Secp256k1"] = 2] = "Secp256k1";
+  keyType[keyType["ECDSA"] = 3] = "ECDSA";
+})(keyType || (keyType = {}));
+//比较两个 Uint8Array  
+const arrayEquals = (a, b) => {
+  if (a.length !== b.length) return false;
+  return a.every((val, i) => val === b[i]);
+};
+const PublicKeyProto = new protobuf__namespace.Type("PublicKey").add(new protobuf__namespace.Field("type", 1, "uint32")).add(new protobuf__namespace.Field("data", 2, "bytes"));
+// ED25519公钥实现  // 更完整的实现  
+class Ed25519PubKey {
+  constructor(publicKey) {
+    Object.defineProperty(this, "raw", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "type", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    if (!(publicKey instanceof Uint8Array)) {
+      throw new Error('Public key must be Uint8Array');
+    }
+    if (publicKey.length !== 32) {
+      throw new Error('ed25519: bad public key length');
+    }
+    this.raw = new Uint8Array(publicKey);
+    this.type = 'Ed25519';
+  }
+  bytes() {
+    return this.raw;
+  }
+  /**
+  * Returns a multihash, the digest of which is the protobuf-encoded public key
+  * encoded as an identity hash
+  */
+  toMultihash() {
+    // 使用 protobuf 编码公钥
+    const protoBytes = Ed25519PubKey.publicKeyToProto(this);
+    const size = protoBytes.length;
+    // 创建 bytes: 格式为 [code(varint), size(varint), ...digest]  
+    const bytes = new Uint8Array(2 + size);
+    bytes[0] = 0x00; // identity hash code  
+    bytes[1] = size; // size in varint  
+    bytes.set(protoBytes, 2);
+    return {
+      code: 0x00,
+      // identity hash code
+      size,
+      digest: protoBytes,
+      bytes
+    };
+  }
+  toCID() {
+    const hash = this.toMultihash();
+    return cid.CID.create(1, 0x72, hash);
+  }
+  equals(other) {
+    return arrayEquals(this.raw, other.raw);
+  }
+  verify(data, sig) {
+    return ed25519.ed25519.verify(sig, data, this.raw);
+  }
+  async encrypt(data) {
+    const encrypted = await curve25519Encryption.Encryption.encrypt(this.raw, data);
+    return encrypted;
+  }
+  static formEd25519PublicKey(publicKey) {
+    return new Ed25519PubKey(publicKey.raw);
+  }
+  static fromMultihash(multihash) {
+    if (multihash.code !== identity.identity.code) {
+      throw new Error('Invalid multihash code');
+    }
+    return new Ed25519PubKey(multihash.digest);
+  }
+  // 从 CID 恢复公钥  
+  static fromCID(cid) {
+    if (cid.code !== 0x72) {
+      // libp2p-key codec  
+      throw new Error('Invalid CID codec');
+    }
+    return Ed25519PubKey.fromMultihash(cid.multihash);
+  }
+  // PublicKeyToProto converts a public key object into an unserialized
+  // protobuf PublicKey message.
+  static publicKeyToProto(k) {
+    const message = {
+      type: keyType.Ed25519,
+      data: k.bytes()
+    };
+    const buffer = Ed25519PubKey.proto.encode(message).finish();
+    return buffer;
+  }
+  // PublicKeyFromProto converts a protobuf PublicKey message into a public key object.
+  static publicKeyFromProto(buf) {
+    const decoded = Ed25519PubKey.proto.decode(buf);
+    if (decoded.type !== keyType.Ed25519) {
+      throw new Error('Invalid key type');
+    }
+    return new Ed25519PubKey(decoded.data);
+  }
+  //与dc中的go代码兼容
+  string() {
+    const protoBytes = Ed25519PubKey.publicKeyToProto(this);
+    // 使用 base32 编码
+    return base32.base32.encode(protoBytes);
+  }
+  // 从字符串创建公钥
+  static unmarshalString(str) {
+    const protoBytes = base32.base32.decode(str);
+    return Ed25519PubKey.publicKeyFromProto(protoBytes);
+  }
+  /**
+    * Returns this key as a multihash with base58btc encoding
+    */
+  toString() {
+    //生成16进制
+    return utils.bytesToHex(this.bytes());
+  }
+  static fromString(str) {
+    return new Ed25519PubKey(utils.hexToBytes(str));
+  }
+  // 转换为 base58 字符串  
+  toBase58() {
+    const hash = this.toMultihash();
+    return base58.base58btc.encode(hash.bytes);
+  }
+  // 从 base58 字符串恢复  
+  static fromBase58(str) {
+    const bytes = base58.base58btc.decode(str);
+    const mh = {
+      code: 0,
+      size: bytes.length - 2,
+      digest: bytes.slice(2),
+      bytes
+    };
+    return Ed25519PubKey.fromMultihash(mh);
+  }
+  static edPubkeyFromStr(pubkey) {
+    if (pubkey.indexOf('0x') === 0) {
+      // hex
+      return Ed25519PubKey.fromString(pubkey.substring(2));
+    } else {
+      // base32
+      return Ed25519PubKey.unmarshalString(pubkey);
+    }
+  }
+}
+Object.defineProperty(Ed25519PubKey, "proto", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: (() => {
+    return PublicKeyProto;
+  })()
+});
+// ED25519私钥实现  
+class Ed25519PrivKey {
+  constructor(privateKey) {
+    Object.defineProperty(this, "type", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "raw", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "publicKey", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    if (privateKey.length !== 64) {
+      throw new Error('ed25519: bad private key length');
+    }
+    // 用复制的方式保存私钥
+    this.raw = new Uint8Array(privateKey);
+    this.type = 'Ed25519';
+    // 公钥是私钥的后32字节  
+    this.publicKey = new Ed25519PubKey(privateKey.slice(32));
+  }
+  static fromSeed(seed) {
+    if (seed.length !== 32) {
+      throw new Error('ed25519: bad seed length');
+    }
+    // 生成公钥  
+    const publicKey = ed25519.ed25519.getPublicKey(seed);
+    // 构造64字节私钥  
+    const privateKey = new Uint8Array(64);
+    privateKey.set(seed);
+    privateKey.set(publicKey, 32);
+    return new Ed25519PrivKey(privateKey);
+  }
+  bytes() {
+    return this.raw;
+  }
+  sign(msg) {
+    // 使用私钥的前32字节（种子）进行签名  
+    return ed25519.ed25519.sign(msg, this.raw.slice(0, 32));
+  }
+  async decrypt(data) {
+    const decrypted = await curve25519Encryption.Encryption.decrypt(this.raw, data);
+    return decrypted;
+  }
+  equals(other) {
+    return arrayEquals(this.bytes(), other.bytes());
+  }
+  // privateKeyToProto converts a public key object into an unserialized
+  // protobuf PrivateKey message.
+  static privateKeyToProto(k) {
+    const message = {
+      type: keyType.Ed25519,
+      data: k.bytes()
+    };
+    const buffer = Ed25519PrivKey.proto.encode(message).finish();
+    return buffer;
+  }
+  // privateKeyFromProto converts a protobuf PrivateKey message into a public key object.
+  static privateKeyFromProto(buf) {
+    const decoded = Ed25519PrivKey.proto.decode(buf);
+    if (decoded.type !== keyType.Ed25519) {
+      throw new Error('Invalid key type');
+    }
+    return new Ed25519PrivKey(decoded.data);
+  }
+  //与dc中的go代码兼容
+  string() {
+    const protoBytes = Ed25519PrivKey.privateKeyToProto(this);
+    // 使用 base32 编码
+    return base32.base32.encode(protoBytes);
+  }
+  // 从字符串创建私钥
+  static unmarshalString(str) {
+    const protoBytes = base32.base32.decode(str);
+    return Ed25519PrivKey.privateKeyFromProto(protoBytes);
+  }
+  toString() {
+    return utils.bytesToHex(this.bytes());
+  }
+  static fromString(str) {
+    return new Ed25519PrivKey(utils.hexToBytes(str));
+  }
+}
+Object.defineProperty(Ed25519PrivKey, "proto", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: (() => {
+    return PublicKeyProto;
+  })()
+});
+// 运行示例  
+//example().catch(console.error)
+
+exports.Ed25519PrivKey = Ed25519PrivKey;
+exports.Ed25519PubKey = Ed25519PubKey;

package/dist/cjs/common/dc-key/keyManager.js

@@ -0,0 +1,285 @@
+'use strict';
+
+var bip39 = require('@scure/bip39');
+var english = require('../../node_modules/@scure/bip39/esm/wordlists/english.js');
+var ed25519$1 = require('../../node_modules/@noble/curves/esm/ed25519.js');
+var sha512 = require('../../node_modules/@noble/hashes/esm/sha512.js');
+var bip32 = require('@scure/bip32');
+var ed25519 = require('./ed25519.js');
+var bcrypt = require('../../util/bcrypt.js');
+var multiaddr = require('@multiformats/multiaddr');
+var peerId = require('@libp2p/peer-id');
+var utils = require('../../util/utils.js');
+
+/**
+ * bcrypt 的成本因子
+ */
+const BCRYPT_COST = 12;
+const DERIVATION_PATHS = {
+  ETHEREUM: "m/44'/60'/0'/0/0",
+  BITCOIN: "m/44'/0'/0'/0/0",
+  FILECOIN: "m/44'/461'/0'/0/0",
+  POLKADOT: "m/44'/354'/0'/0'/0'",
+  SOLANA: "m/44'/501'/0'/0'",
+  COSMOS: "m/44'/118'/0'/0/0"
+};
+class KeyManager {
+  // MnemonicToEntropy 将助记词转换为熵  
+  // 如果助记词无效，则抛出错误  
+  mnemonicToEntropy(mnemonic) {
+    // 验证助记词的有效性，传入英文单词表  
+    if (!bip39.validateMnemonic(mnemonic, english.wordlist)) {
+      throw new Error('无效的助记词');
+    }
+    // 使用 @scure/bip39 将助记词转换为熵的 Uint8Array，传入英文单词表  
+    const entropy = bip39.mnemonicToEntropy(mnemonic, english.wordlist);
+    return entropy;
+  }
+  // SeedFromMnemonic 从 BIP39 助记词和密码生成 64 字节的种子  
+  async seedFromMnemonic(mnemonic, password) {
+    // 将助记词转换为熵  
+    const entropy = this.mnemonicToEntropy(mnemonic);
+    // 验证熵的长度：必须在 16 到 32 字节之间，并且是 4 的倍数  
+    if (entropy.length < 16 || entropy.length > 32 || entropy.length % 4 !== 0) {
+      throw new Error("无效的熵长度");
+    }
+    // 准备盐值："mnemonic" + password  
+    const saltStr = KeyManager.SCHNORRKEL_SEED_PREFIX + password;
+    const encoder = new TextEncoder();
+    const salt = encoder.encode(saltStr);
+    // 使用 Web Crypto API 导入熵作为 PBKDF2 的密钥  
+    const key = await crypto.subtle.importKey('raw', entropy, {
+      name: 'PBKDF2'
+    }, false, ['deriveBits']);
+    // 使用 PBKDF2 生成 64 字节（512 位）的种子，迭代次数为 2048，使用 SHA-512 哈希算法  
+    const derivedBits = await crypto.subtle.deriveBits({
+      name: 'PBKDF2',
+      salt: salt,
+      iterations: 2048,
+      hash: 'SHA-512'
+    }, key, 64 * 8 // 64 字节 = 512 位  
+    );
+    // 将导出的位转换为 Uint8Array  
+    const derivedBytes = new Uint8Array(derivedBits);
+    return derivedBytes;
+  }
+  async getEd25519KeyFromMnemonic(mnemonic) {
+    let password = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    // 使用兼容 Schnorrkel 的方式生成种子  
+    const seed = await this.seedFromMnemonic(mnemonic, password);
+    const ed25519Key = this.newKeyFromSeed(seed.slice(0, 32));
+    const privateKey = new ed25519.Ed25519PrivKey(ed25519Key.privateKey);
+    // 安全清除内存中的敏感数据  
+    KeyManager.clearSensitiveData(seed);
+    KeyManager.clearSensitiveData(ed25519Key.privateKey);
+    return privateKey;
+  }
+  newKeyFromSeed(seed) {
+    if (seed.length !== KeyManager.SEED_SIZE) {
+      throw new Error(`ed25519: bad seed length: ${seed.length}`);
+    }
+    // 1. 计算种子的 SHA-512 哈希  
+    const h = sha512.sha512(seed);
+    // 2. 对前32字节进行clamping（与Go实现一致）  
+    const h0 = h.slice(0, 32);
+    h0[0] &= 248;
+    h0[31] &= 127;
+    h0[31] |= 64;
+    // 3. 生成公钥  
+    const publicKey = ed25519$1.ed25519.getPublicKey(seed);
+    // 4. 构造64字节私钥（种子 + 公钥）  
+    const privateKey = new Uint8Array(KeyManager.PRIVATE_KEY_SIZE);
+    privateKey.set(seed); // 前32字节是种子  
+    privateKey.set(publicKey, 32); // 后32字节是公钥  
+    return {
+      privateKey,
+      publicKey
+    };
+  }
+  // 生成新的助记词  
+  static generateMnemonic() {
+    let strength = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 256;
+    // strength: 128 生成12个词, 256生成24个词  
+    return bip39.generateMnemonic(english.wordlist, strength);
+  }
+  // 验证助记词  
+  static validateMnemonic(mnemonic) {
+    return bip39.validateMnemonic(mnemonic, english.wordlist);
+  }
+  // 原始的 HD 钱包方式  
+  static async getMasterKeyFromMnemonic(mnemonic) {
+    let password = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    if (!this.validateMnemonic(mnemonic)) {
+      throw new Error('Invalid mnemonic');
+    }
+    const seed = await bip39.mnemonicToSeed(mnemonic, password);
+    return bip32.HDKey.fromMasterSeed(seed);
+  }
+  // 派生特定路径的密钥  
+  static async deriveKey(mnemonic) {
+    let path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "m/44'/60'/0'/0/0";
+    let password = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    const masterKey = await this.getMasterKeyFromMnemonic(mnemonic, password);
+    const derivedKey = masterKey.derive(path);
+    if (!derivedKey.privateKey || !derivedKey.publicKey) {
+      throw new Error('Failed to derive key');
+    }
+    return {
+      privateKey: derivedKey.privateKey,
+      publicKey: derivedKey.publicKey
+    };
+  }
+  static async deriveKeyForChain(mnemonic, chain) {
+    let password = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    return await this.deriveKey(mnemonic, DERIVATION_PATHS[chain], password);
+  }
+  // 安全清除数据  
+  static clearSensitiveData(data) {
+    data.fill(0);
+  }
+}
+Object.defineProperty(KeyManager, "SEED_SIZE", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 32
+});
+Object.defineProperty(KeyManager, "PRIVATE_KEY_SIZE", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 64
+});
+Object.defineProperty(KeyManager, "PUBLIC_KEY_SIZE", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 32
+});
+// Schnorrkel 常量  
+Object.defineProperty(KeyManager, "SCHNORRKEL_SEED_PREFIX", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 'mnemonic'
+});
+/**
+ * 从 PeerId 中提取公钥 ,只支持 Ed25519PubKey
+ * @param peerId libp2p PeerId 实例
+ * @returns 提取的公钥
+ */
+async function extractPublicKeyFromPeerId(peerId) {
+  try {
+    if (peerId.type === "Ed25519") {
+      if (peerId.publicKey != null) {
+        return ed25519.Ed25519PubKey.formEd25519PublicKey(peerId.publicKey);
+      }
+    }
+    // 如果无法从 PeerId 中直接获取公钥
+    throw new Error("Unable to extract public key from PeerId");
+  } catch (error) {
+    throw new Error(`Failed to extract public key: ${error.message}`);
+  }
+}
+/**
+ * 从 Multiaddr 中提取 PeerId
+ * @param addr Multiaddr 实例或字符串
+ * @returns PeerId 实例
+ */
+async function extractPeerIdFromMultiaddr(addr) {
+  try {
+    // 确保地址是 Multiaddr 实例
+    const multiAddr = typeof addr === "string" ? multiaddr.multiaddr(addr) : addr;
+    // 获取 p2p 或 ipfs 协议的值
+    const p2pValue = multiAddr.getPeerId();
+    if (!p2pValue) {
+      throw new Error("No PeerId found in multiaddr");
+    }
+    // 从字符串创建 PeerId
+    return peerId.peerIdFromString(p2pValue);
+  } catch (error) {
+    throw new Error(`Failed to extract PeerId: ${error.message}`);
+  }
+}
+/**
+ * 从字节数组生成对称密钥
+ * @param bytes - 输入字节数组
+ * @returns Promise<SymKey> - 返回对称密钥
+ */
+async function symKeyFromBytes(bytes) {
+  const key = await window.crypto.subtle.importKey("raw", bytes, {
+    name: "AES-GCM"
+  }, true, ["encrypt", "decrypt"]);
+  return {
+    key,
+    raw: bytes
+  };
+}
+/**
+ * 生成用户私钥加解密的密钥
+ * @param account - 用户账号
+ * @param password - 用户密码
+ * @returns Promise<SymKey> - 返回对称加密密钥
+ */
+async function generateSymKeyForPrikey(account, password) {
+  try {
+    // 计算密码的 SHA256 哈希
+    const passwordHash = await utils.sha256(new TextEncoder().encode(password));
+    // 从哈希中提取盐值（与 Go 代码保持一致，使用后16字节）
+    const salt = passwordHash.slice(16, 32);
+    // 使用 bcrypt 生成哈希
+    const bcryptHash = await bcrypt.generateFromPasswordWithSalt(passwordHash, BCRYPT_COST, salt);
+    const hash = bcryptHash.hash;
+    // 将 account 转换为字节数组
+    const accountBytes = new TextEncoder().encode(account);
+    // 合并 bcryptHash 和 account 字节
+    const combined = new Uint8Array(hash.length + accountBytes.length);
+    combined.set(hash);
+    combined.set(accountBytes, hash.length);
+    // 计算最终的 SHA256 哈希
+    const keyBytes = await utils.sha256(combined);
+    // 从字节生成对称密钥
+    return await symKeyFromBytes(keyBytes);
+  } catch (error) {
+    throw new Error(`Failed to generate symmetric key: ${error.message}`);
+  }
+}
+/**
+ * 将 Ed25519 私钥转换为 CryptoKey
+ * @param privateKey - 输入的私钥（支持多种格式）
+ * @param format - 密钥格式（默认自动检测）
+ */
+async function ed25519PrivateKeyToCryptoKey(privateKey) {
+  let format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'pkcs8';
+  // 1. 统一转换为 ArrayBuffer  
+  let keyData;
+  if (typeof privateKey === 'string') {
+    // 处理 PEM 格式（自动识别 PKCS8）  
+    if (privateKey.startsWith('-----BEGIN')) {
+      const pemHeader = '-----BEGIN PRIVATE KEY-----';
+      const pemFooter = '-----END PRIVATE KEY-----';
+      const pemContents = privateKey.replace(pemHeader, '').replace(pemFooter, '').replace(/\s+/g, '');
+      keyData = Uint8Array.from(atob(pemContents), c => c.charCodeAt(0));
+    } else {
+      // 处理 Base64/Hex 编码的 RAW 格式  
+      keyData = Uint8Array.from(atob(privateKey), c => c.charCodeAt(0));
+    }
+  } else {
+    keyData = privateKey;
+  }
+  // 2. 检测密钥格式  
+  const detectedFormat = format === 'pkcs8' || privateKey instanceof Uint8Array ? format : 'pkcs8';
+  // 3. 导入为 CryptoKey  
+  return crypto.subtle.importKey(detectedFormat, keyData, {
+    name: 'Ed25519',
+    namedCurve: 'Ed25519'
+  }, true, ['sign']);
+}
+
+exports.DERIVATION_PATHS = DERIVATION_PATHS;
+exports.KeyManager = KeyManager;
+exports.ed25519PrivateKeyToCryptoKey = ed25519PrivateKeyToCryptoKey;
+exports.extractPeerIdFromMultiaddr = extractPeerIdFromMultiaddr;
+exports.extractPublicKeyFromPeerId = extractPublicKeyFromPeerId;
+exports.generateSymKeyForPrikey = generateSymKeyForPrikey;
+exports.symKeyFromBytes = symKeyFromBytes;

package/dist/cjs/common/dcapi.js

@@ -0,0 +1,89 @@
+'use strict';
+
+var grpcDc = require('./grpc-dc.js');
+
+class Client {
+  constructor(node, blockstore, peerAddr, protocol) {
+    Object.defineProperty(this, "protocol", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "p2pNode", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "blockstore", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "peerAddr", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "token", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.protocol = protocol;
+    this.p2pNode = node;
+    this.peerAddr = peerAddr;
+    this.token = "";
+    this.blockstore = blockstore;
+  }
+  async GetToken(appId, pubkey, signCallback, peerAddr) {
+    try {
+      if (this.p2pNode == null) {
+        throw new Error("p2pNode is null");
+      }
+      if (!peerAddr) {
+        peerAddr = this.peerAddr;
+      }
+      if (!pubkey || pubkey.length == 0) {
+        throw new Error("pubkey is empty");
+      }
+      const grpcClient = new grpcDc.DCGrpcClient(this.p2pNode, peerAddr, this.token, this.protocol);
+      const token = await grpcClient.GetToken(appId, pubkey, signCallback);
+      this.token = token;
+      return token;
+    } catch (err) {
+      console.error("GetToken error:", err);
+      return "";
+    }
+  }
+  // 清除token
+  async ClearToken() {
+    this.token = "";
+  }
+  // 验证token
+  async ValidToken(peerAddr) {
+    try {
+      if (this.p2pNode == null) {
+        throw new Error("p2pNode is null");
+      }
+      if (!peerAddr) {
+        peerAddr = this.peerAddr;
+      }
+      const grpcClient = new grpcDc.DCGrpcClient(this.p2pNode, peerAddr, this.token, this.protocol);
+      await grpcClient.ValidToken();
+    } catch (err) {
+      throw err;
+    }
+  }
+  // 获取Token
+  async refreshToken(appId, pubkey, signCallback, peerAddr) {
+    this.ClearToken();
+    return await this.GetToken(appId, pubkey, signCallback, peerAddr);
+  }
+}
+
+exports.Client = Client;