gamerpc 9.0.0 → 9.0.1

package/test/utils/secp256k1.js

@@ -0,0 +1,444 @@
+/**
+ * secp256k1 加密单元测试
+ * 使用已知测试向量，验证 @noble/secp256k1 封装层与 elliptic 的等价性
+ *
+ * 测试向量来源：
+ *   - RFC 6979 (Deterministic ECDSA)
+ *   - Bitcoin BIP32 test vectors
+ *   - secp256k1 标准测试向量
+ */
+const assert = require('assert');
+const secp = require('../../src/utils/secp256k1');
+
+// ============================================================
+// Helper
+// ============================================================
+const hex = (buf) => Buffer.isBuffer(buf) ? buf.toString('hex') : buf;
+
+describe('secp256k1 封装层单元测试', function () {
+
+  // ==========================================================
+  // 1. 密钥生成
+  // ==========================================================
+  describe('密钥生成', function () {
+    it('generatePrivateKey: 生成 32 字节私钥', function () {
+      const priv = secp.generatePrivateKey();
+      assert(Buffer.isBuffer(priv));
+      assert.strictEqual(priv.length, 32);
+    });
+
+    it('generatePrivateKey: 连续两次生成的私钥不同', function () {
+      const a = secp.generatePrivateKey();
+      const b = secp.generatePrivateKey();
+      assert(!a.equals(b));
+    });
+
+    it('privateKeyVerify: 有效私钥返回 true', function () {
+      const priv = secp.generatePrivateKey();
+      assert.strictEqual(secp.privateKeyVerify(priv), true);
+    });
+
+    it('privateKeyVerify: 全零私钥返回 false', function () {
+      assert.strictEqual(secp.privateKeyVerify(Buffer.alloc(32, 0)), false);
+    });
+
+    it('privateKeyVerify: 超范围私钥返回 false', function () {
+      // n = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+      const n = Buffer.from('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 'hex');
+      assert.strictEqual(secp.privateKeyVerify(n), false);
+    });
+
+    it('privateKeyVerify: 长度不是 32 返回 false', function () {
+      assert.strictEqual(secp.privateKeyVerify(Buffer.alloc(31, 1)), false);
+      assert.strictEqual(secp.privateKeyVerify(Buffer.alloc(33, 1)), false);
+    });
+  });
+
+  // ==========================================================
+  // 2. 公钥创建与验证
+  // ==========================================================
+  describe('公钥操作', function () {
+    // 已知测试向量：私钥 1 → 压缩公钥
+    // priv=1 → pub=0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
+    const PRIV_ONE = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex');
+    const PUB_ONE_COMPRESSED = '0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798'.toLowerCase();
+    const PUB_ONE_UNCOMPRESSED = '0479BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8'.toLowerCase();
+
+    it('publicKeyCreate: 已知私钥生成压缩公钥', function () {
+      const pub = secp.publicKeyCreate(PRIV_ONE, true);
+      assert.strictEqual(hex(pub), PUB_ONE_COMPRESSED);
+    });
+
+    it('publicKeyCreate: 已知私钥生成非压缩公钥', function () {
+      const pub = secp.publicKeyCreate(PRIV_ONE, false);
+      assert.strictEqual(hex(pub), PUB_ONE_UNCOMPRESSED);
+    });
+
+    it('publicKeyCreate: 默认生成压缩公钥', function () {
+      const pub = secp.publicKeyCreate(PRIV_ONE);
+      assert.strictEqual(pub.length, 33);
+    });
+
+    it('publicKeyConvert: 压缩→非压缩', function () {
+      const compressed = secp.publicKeyCreate(PRIV_ONE, true);
+      const uncompressed = secp.publicKeyConvert(compressed, false);
+      assert.strictEqual(hex(uncompressed), PUB_ONE_UNCOMPRESSED);
+    });
+
+    it('publicKeyConvert: 非压缩→压缩', function () {
+      const uncompressed = secp.publicKeyCreate(PRIV_ONE, false);
+      const compressed = secp.publicKeyConvert(uncompressed, true);
+      assert.strictEqual(hex(compressed), PUB_ONE_COMPRESSED);
+    });
+
+    it('publicKeyVerify: 有效公钥返回 true', function () {
+      assert.strictEqual(secp.publicKeyVerify(Buffer.from(PUB_ONE_COMPRESSED, 'hex')), true);
+      assert.strictEqual(secp.publicKeyVerify(Buffer.from(PUB_ONE_UNCOMPRESSED, 'hex')), true);
+    });
+
+    it('publicKeyVerify: 无效公钥返回 false', function () {
+      assert.strictEqual(secp.publicKeyVerify(Buffer.alloc(33, 0)), false);
+      assert.strictEqual(secp.publicKeyVerify(Buffer.alloc(0)), false);
+    });
+
+    it('generateKey → publicKeyCreate: 生成密钥对一致性', function () {
+      for (let i = 0; i < 10; i++) {
+        const priv = secp.generatePrivateKey();
+        const pubC = secp.publicKeyCreate(priv, true);
+        const pubU = secp.publicKeyCreate(priv, false);
+        // 验证压缩/非压缩表示同一公钥
+        const converted = secp.publicKeyConvert(pubC, false);
+        assert.strictEqual(hex(converted), hex(pubU));
+      }
+    });
+  });
+
+  // ==========================================================
+  // 3. 签名与验证 (RFC 6979 确定性签名)
+  // ==========================================================
+  describe('签名与验证', function () {
+    // RFC 6979 Appendix A.2.5 测试向量
+    // SHA-256("sample")
+    const RFC6979_PRIV = Buffer.from('C9AFA9D845BA75166B5C215767B1D6934E50C3DB36E89B127B8A622B120F6721', 'hex');
+    const RFC6979_MSG = Buffer.from('AF2BDBE1AA9B6EC1E2ADE1D694F41FC71A831D0268E9891562113D8A62ADD1BF', 'hex');
+    // 这个私钥对 "sample" 签名应该能验证
+    const SAMPLE_HASH = Buffer.from('AF2BDBE1AA9B6EC1E2ADE1D694F41FC71A831D0268E9891562113D8A62ADD1BF', 'hex');
+
+    it('sign: 生成 DER 签名', function () {
+      const sig = secp.sign(SAMPLE_HASH, RFC6979_PRIV);
+      assert(Buffer.isBuffer(sig));
+      // DER 签名长度大约 70-73 字节
+      assert(sig.length >= 68 && sig.length <= 73, `unexpected sig length: ${sig.length}`);
+    });
+
+    it('sign → verify: 签名后可成功验证 (同一密钥)', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey(); // 32 random bytes
+
+      const sig = secp.sign(msg, priv);
+      const result = secp.verify(msg, sig, pub);
+      assert.strictEqual(result, true);
+    });
+
+    it('verify: 错误公钥无法验证', function () {
+      const privA = secp.generatePrivateKey();
+      const privB = secp.generatePrivateKey();
+      const pubB = secp.publicKeyCreate(privB, true);
+      const msg = secp.generatePrivateKey();
+
+      const sig = secp.sign(msg, privA);
+      const result = secp.verify(msg, sig, pubB);
+      assert.strictEqual(result, false);
+    });
+
+    it('verify: 篡改消息无法验证', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey();
+
+      const sig = secp.sign(msg, priv);
+      const tampered = Buffer.from(msg);
+      tampered[0] ^= 1;
+      const result = secp.verify(tampered, sig, pub);
+      assert.strictEqual(result, false);
+    });
+
+    it('verify: 空签名返回 false', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey();
+      assert.strictEqual(secp.verify(msg, Buffer.alloc(0), pub), false);
+    });
+
+    it('verify: 空公钥返回 false', function () {
+      const priv = secp.generatePrivateKey();
+      const msg = secp.generatePrivateKey();
+      const sig = secp.sign(msg, priv);
+      assert.strictEqual(secp.verify(msg, sig, Buffer.alloc(0)), false);
+    });
+
+    it('确定性: 同一消息和私钥产生相同签名', function () {
+      const priv = secp.generatePrivateKey();
+      const msg = secp.generatePrivateKey();
+      const sig1 = secp.sign(msg, priv);
+      const sig2 = secp.sign(msg, priv);
+      assert(hex(sig1) === hex(sig2), 'deterministic signatures must be identical');
+    });
+
+    it('不同消息产生不同签名', function () {
+      const priv = secp.generatePrivateKey();
+      const msg1 = secp.generatePrivateKey();
+      const msg2 = secp.generatePrivateKey();
+      // 确保消息不同
+      while (msg1.equals(msg2)) {
+        msg2.fill(0);
+        msg2[0] = msg1[0] ^ 0xFF;
+      }
+      const sig1 = secp.sign(msg1, priv);
+      const sig2 = secp.sign(msg2, priv);
+      assert(!sig1.equals(sig2));
+    });
+  });
+
+  // ==========================================================
+  // 4. DER 格式转换
+  // ==========================================================
+  describe('DER 格式转换', function () {
+    it('toDER → fromDER: 往返转换', function () {
+      const priv = secp.generatePrivateKey();
+      const msg = secp.generatePrivateKey();
+      const der = secp.sign(msg, priv);
+
+      const compact = secp.fromDER(der);
+      assert.strictEqual(compact.length, 64);
+
+      const der2 = secp.toDER(compact);
+      // 重新解析验证
+      const compact2 = secp.fromDER(der2);
+      assert.strictEqual(hex(compact), hex(compact2));
+    });
+
+    it('toDER → verify: 往返后可验证', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey();
+      const der = secp.sign(msg, priv);
+
+      const compact = secp.fromDER(der);
+      const der2 = secp.toDER(compact);
+
+      assert.strictEqual(secp.verify(msg, der2, pub), true);
+    });
+
+    it('fromDER: 无效输入不崩溃', function () {
+      // 无效 DER 应该抛出或返回异常值
+      try {
+        secp.fromDER(Buffer.alloc(10, 0xFF));
+        // 如果没抛异常也是可以接受的，只要不崩溃
+      } catch (e) {
+        // 预期可能抛异常
+      }
+    });
+
+    it('toDER → isLowS: 低S值验证', function () {
+      const priv = secp.generatePrivateKey();
+      const msg = secp.generatePrivateKey();
+      const der = secp.sign(msg, priv);
+      assert.strictEqual(secp.isLowS(der), true, 'normal signature should have low S');
+    });
+
+    it('isLowS: 无效输入返回 false', function () {
+      assert.strictEqual(secp.isLowS(Buffer.alloc(0)), false);
+      assert.strictEqual(secp.isLowS(Buffer.alloc(10, 0xFF)), false);
+    });
+  });
+
+  // ==========================================================
+  // 5. ECDH 密钥交换
+  // ==========================================================
+  describe('ECDH 密钥交换', function () {
+    it('ecdh: 双方计算得到相同的共享密钥', function () {
+      const privA = secp.generatePrivateKey();
+      const privB = secp.generatePrivateKey();
+      const pubA = secp.publicKeyCreate(privA, true);
+      const pubB = secp.publicKeyCreate(privB, true);
+
+      const sharedA = secp.ecdh(pubB, privA); // A用B的公钥+自己的私钥
+      const sharedB = secp.ecdh(pubA, privB); // B用A的公钥+自己的私钥
+
+      assert.strictEqual(hex(sharedA), hex(sharedB));
+    });
+
+    it('ecdh: 返回 32 字节', function () {
+      const privA = secp.generatePrivateKey();
+      const privB = secp.generatePrivateKey();
+      const pubB = secp.publicKeyCreate(privB, true);
+
+      const shared = secp.ecdh(pubB, privA);
+      assert.strictEqual(shared.length, 32);
+    });
+
+    it('ecdh: 不同密钥对产生不同共享密钥', function () {
+      const p1 = secp.generatePrivateKey();
+      const p2 = secp.generatePrivateKey();
+      const p3 = secp.generatePrivateKey();
+      const pub2 = secp.publicKeyCreate(p2, true);
+      const pub3 = secp.publicKeyCreate(p3, true);
+
+      const s12 = secp.ecdh(pub2, p1);
+      const s13 = secp.ecdh(pub3, p1);
+      assert(!s12.equals(s13));
+    });
+  });
+
+  // ==========================================================
+  // 6. 公钥恢复
+  // ==========================================================
+  describe('公钥恢复', function () {
+    it('recover: 可从签名恢复原公钥', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey();
+      const sig = secp.sign(msg, priv);
+
+      // 尝试 4 种 recovery id
+      let recovered = null;
+      for (let j = 0; j < 4; j++) {
+        const rec = secp.recover(msg, sig, j, true);
+        if (rec && hex(rec) === hex(pub)) {
+          recovered = rec;
+          break;
+        }
+      }
+      assert(recovered !== null, 'should recover the original public key');
+    });
+
+    it('recover: 无效签名返回 null', function () {
+      const msg = secp.generatePrivateKey();
+      const invalidSig = Buffer.alloc(70, 0xFF);
+      const result = secp.recover(msg, invalidSig, 0, true);
+      assert.strictEqual(result, null);
+    });
+  });
+
+  // ==========================================================
+  // 7. Tweak 操作
+  // ==========================================================
+  describe('Tweak 操作', function () {
+    it('privateKeyTweakAdd: (key + tweak) % n', function () {
+      const priv = secp.generatePrivateKey();
+      const tweak = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex');
+      const tweaked = secp.privateKeyTweakAdd(priv, tweak);
+      assert.strictEqual(tweaked.length, 32);
+      assert(secp.privateKeyVerify(tweaked));
+      // 加1后应该与原私钥不同（除非原私钥恰好是n-1）
+      if (hex(priv) !== 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140') {
+        assert(!tweaked.equals(priv));
+      }
+    });
+
+    it('publicKeyTweakAdd: G * tweak + pubkey', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const tweak = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex');
+
+      const tweakedPub = secp.publicKeyTweakAdd(pub, tweak, true);
+      assert.strictEqual(tweakedPub.length, 33);
+      assert(secp.publicKeyVerify(tweakedPub));
+
+      // 验证：手动加1后私钥的公钥应等于原公钥加G
+      const tweakedPriv = secp.privateKeyTweakAdd(priv, tweak);
+      const expectedPub = secp.publicKeyCreate(tweakedPriv, true);
+      assert.strictEqual(hex(tweakedPub), hex(expectedPub),
+        'publicKeyTweakAdd result should match privateKeyTweakAdd + publicKeyCreate');
+    });
+  });
+
+  // ==========================================================
+  // 8. binding 常量
+  // ==========================================================
+  describe('常量', function () {
+    it('binding: 始终为 false (非native)', function () {
+      assert.strictEqual(secp.binding, false);
+    });
+  });
+
+  // ==========================================================
+  // 9. verifyData + secret 集成测试
+  // ==========================================================
+  describe('上层集成: verifyData & Secret', function () {
+    const verifyData = require('../../src/utils/verifyData');
+    const Secret = require('../../src/utils/secret');
+
+    it('generateKey → signObj → verifyObj: 完整流程', function () {
+      const keys = verifyData.generateKey();
+      assert.strictEqual(typeof keys.private, 'string');
+      assert.strictEqual(typeof keys.public, 'string');
+      assert.strictEqual(keys.private.length, 64); // hex of 32 bytes
+      assert.strictEqual(keys.public.length, 66);   // hex of 33 bytes (compressed)
+
+      const obj = { action: 'transfer', amount: 100, to: 'abc' };
+      const sig = verifyData.signObj(obj, keys.private);
+      assert.strictEqual(typeof sig, 'string');
+
+      const ok = verifyData.verifyObj(obj, sig, keys.public);
+      assert.strictEqual(ok, true);
+    });
+
+    it('generateKey: 用已知私钥生成公钥', function () {
+      const privHex = '0000000000000000000000000000000000000000000000000000000000000001';
+      const keys = verifyData.generateKey(privHex);
+      assert.strictEqual(keys.private, privHex);
+      // 压缩公钥，33字节 hex = 66 chars
+      assert.strictEqual(keys.public.length, 66);
+    });
+
+    it('verifyObj: 错误签名应失败', function () {
+      const keysA = verifyData.generateKey();
+      const keysB = verifyData.generateKey();
+      const obj = { msg: 'test' };
+      const sig = verifyData.signObj(obj, keysA.private);
+      // 用B的公钥验证A的签名 → 应该失败
+      const ok = verifyData.verifyObj(obj, sig, keysB.public);
+      assert.strictEqual(ok, false);
+    });
+
+    it('verifyObj: 篡改消息应失败', function () {
+      const keys = verifyData.generateKey();
+      const obj = { msg: 'test' };
+      const sig = verifyData.signObj(obj, keys.private);
+      const tampered = { msg: 'hacked' };
+      const ok = verifyData.verifyObj(tampered, sig, keys.public);
+      assert.strictEqual(ok, false);
+    });
+
+    it('Secret: 创建、握手、获取公钥', function () {
+      const secret = new Secret();
+      const pub = secret.input.getPublicKey();
+      assert(Buffer.isBuffer(pub));
+      assert.strictEqual(pub.length, 33);
+
+      const priv = secret.input.privateKey;
+      assert(Buffer.isBuffer(priv));
+      assert.strictEqual(priv.length, 32);
+      assert(secp.privateKeyVerify(priv));
+    });
+
+    it('Secret: 双方握手后共享密钥一致', function () {
+      const alice = new Secret();
+      const bob = new Secret();
+
+      const alicePub = alice.input.getPublicKey();
+      const bobPub = bob.input.getPublicKey();
+
+      alice.input.init(bobPub);
+      bob.output.init(alicePub);
+
+      // 双方应完成 ECDH
+      assert.strictEqual(alice.input.sid.length, 32);
+      assert.strictEqual(bob.output.sid.length, 32);
+    });
+  });
+
+});

package/webpack.config.js

@@ -13,13 +13,14 @@ module.exports = {
     },
     globalObject: 'typeof self !== \'undefined\' ? self : this',
   },
+  target: 'web',
   resolve: {
     // webpack 5: 为浏览器环境提供 Node.js 核心模块 polyfill
     fallback: {
       buffer: require.resolve('buffer/'),
       assert: require.resolve('assert/build/assert'),
       stream: require.resolve('stream-browserify'),
-      crypto: require.resolve('crypto-browserify'),
+      crypto: false,  // let @noble/* use globalThis.crypto (Web Crypto API in browsers)
       util: require.resolve('util/'),
       events: require.resolve('events/'),
       url: require.resolve('url/'),
@@ -43,5 +44,4 @@ module.exports = {
       process: 'process/browser',
     }),
   ],
-  target: 'web',
 };

package/.babelrc

@@ -1,16 +0,0 @@
-{
-    "presets": [
-        ["env"],
-        ["es2015", { "modules": false }],
-        ["stage-2"]
-    ],
-    "plugins": [[
-        "transform-runtime",
-        {
-            "helpers": false,
-            "polyfill": false,
-            "regenerator": true,
-            "moduleName": "babel-runtime"
-        }
-    ]]
-}

package/docs/2026.07.15.md

@@ -1,142 +0,0 @@
-# gamerpc 版本演进分析 (V6.0.6 → V7.1.2 → V8.0.8)
-
-> 分析日期：2026-07-15
-
-## Git 仓库地址
-
-- **当前 remote**: `https://gitee.com/bianque/gamegoldtoolkit.git`
-- **package.json 中标注**: `https://github.com/bookmansoft/gamegoldtoolkit`
-
-两个地址可能指向同一仓库（镜像），或 GitHub 为原始仓库、Gitee 为镜像。
-
----
-
-## 版本概览
-
-| 版本 | Commit | 日期 | 提交信息 |
-|------|--------|------|----------|
-| V6.0.6 | `1c9fabd` | 2021-07-03 | 6.0.6 |
-| V7.1.2 | `f5ba0e3` | 2023-11-14 | 7.1.2 |
-| V8.0.8 | `d80155e` | 2024-02-03 | RPC更新: 支持HTTPS切换 |
-
----
-
-## V6.0.6 — 双连接器架构
-
-**时间**：2021-07-03
-
-**架构：双轨并行**
-
-```
-toolkit.conn      → authConn.js    (主网/区块链全节点连接器)
-toolkit.gameconn  → gameConn.js    (游戏云服务器连接器)
-```
-
-**特征**：
-- `index.js` 同时导出两个独立的连接器类
-- 工具函数（`encrypt`、`decrypt`、`signObj`、`verifyObj`、`hash256` 等）在 `index.js` 中**统一**往两个连接器的 `prototype` 上挂载
-- `authConn.js` 的注释是"访问游戏金节点的远程调用函数"，区块链节点当时被称为"游戏金节点"
-- **同时兼容游戏连接器和区块链连接器**的全功能版本
-
----
-
-## V7.1.2 — 工具函数内聚 + 浏览器兼容
-
-**时间**：2023-11-14
-
-**V6.0.6 → V7.1.2 变化**（4 个提交，85 行增/57 行删）：
-
-### V7.0.0 变更 (2021-09-03)
-配合 Vallnet 2.0 使用：
-
-| 变更 | 说明 |
-|------|------|
-| 工具函数挂载方式重构 | 从 `index.js` 统一挂载改为各模块内部自行挂载。`authConn.js` 和 `gameConn.js` 各自 import 并挂载工具函数到 prototype，`index.js` 中删除对应的挂载代码 |
-| 注释更新 | `authConn.js` 注释从"访问游戏金节点"改为"访问全节点"——概念泛化 |
-| 新增验证模式 | `gameConn.js` 新增 `bxs` 验证模式支持 |
-
-### V7.1.x 变更
-
-| 变更 | 说明 |
-|------|------|
-| 认证流程调整 | `gameConn.js` 中登录验证模式从 `domain` 字段改为用 `openid` 字段做路由判断 |
-| 浏览器兼容 | 引入本地 `src/utils/socket.io.min.js`，`gameConn` 改用此本地文件而非 npm 包的 `io`——解决浏览器环境兼容问题 |
-| Node.js 兼容 | build 命令添加 `NODE_OPTIONS=--openssl-legacy-provider`，解决新版 Node.js 的 OpenSSL 3.0 兼容问题 |
-| 主入口变更 | `main` 从 `index.js` 改为打包产物 `./lib/gamerpc7.1.2.js` |
-
----
-
-## V8.0.8 — 大合并：偏重游戏云，去除区块链
-
-**时间**：2024-02-03
-
-**V7.1.2 → V8.0.8 变化**（5 个提交，902 行增/1515 行删）：
-
-### V8.0.3 — 初步精简 (2023-11-15)
-
-- `index.js` 中**注释掉大量区块链相关工具函数**的导出：
-  `encrypt`、`decrypt`、`verifyData`、`generateKey`、`signObj`、`verifyObj`、`verifyAddress`、`hash256`、`hash160`、`sha1`、`Secret`、`createHmac`
-- `gameConn.js` 内部同样注释掉对应工具函数的 import 和挂载
-- **移除 `toolkit.conn` 导出**——区块链连接器不再对外暴露，只保留 `toolkit.gameconn`
-- `gameConn` 中 socket 连接从本地 `ioclient` 回归 npm 包 `io`
-
-### V8.0.5 — util.js 重构
-
-- `src/utils/util.js` 大幅重构，精简约 62 行代码
-
-### V8.0.6 — 清理本地 socket.io
-
-- **删除 `src/utils/socket.io.min.js`**——不再本地内嵌 socket.io，完全回归 npm 依赖
-
-### V8.0.7 — 彻底合并
-
-- **删除 `src/authConn.js`**（595行）——全节点/区块链连接器代码彻底移除
-- **删除 `src/gameConn.js`**（705行）——游戏云连接器代码移除
-- 所有连接器逻辑合并入 `src/index.js`，变成一个统一的 `Remote` 类（约 700 行）
-- 出口从 `exports` 对象变为 `module.exports = Remote`（单一类导出）
-- 注释掉 `assert`、`encrypt`、`decrypt`、`verifyData` 等区块链相关工具的挂载
-
-### V8.0.8 — 支持 HTTPS 切换
-
-- `createSocket` 不再接受 ip/port 参数，改为完全从 `this.config.webserver` 读取
-- 新增 `url` 字段支持：当 `config.webserver.url` 存在时直接使用完整 URL
-  - `ws://host:port` → 直接使用 `wss://url`
-  - `http://host:port` → 直接使用 `https://url`
-  - 支持通过配置切换 HTTP/HTTPS、WS/WSS，适配 CDN/反向代理场景
-- `locate` 函数新增 `url` 参数：`locate(host, port, url)`
-- `getRequest` / `postRequest` 中 URL 拼接逻辑引入 `url` 优先策略
-- **删除 `getOpenId` 方法**——微信相关 OpenId 转换认证流程被移除
-- 删除 `login` 流程中微信 OpenId 转换的检测步骤
-- 在 README 中补充页面嵌入模式的使用说明
-
----
-
-## 演进总览
-
-| 维度 | V6.0.6 | V7.1.2 | V8.0.8 |
-|------|--------|--------|--------|
-| **连接器数量** | 2 个（区块链 + 游戏云） | 2 个 | 1 个（仅游戏云） |
-| **区块链支持** | 完整支持 | 保留但内聚 | **已移除** |
-| **工具函数** | index.js 统一挂载 | 各自模块内部挂载 | 大量注释掉，只保留 `stringify`/`CommMode` 等基础 |
-| **出口方式** | `toolkit.conn` + `toolkit.gameconn` | 同左 | `module.exports = Remote` |
-| **socket 连接方式** | npm `io` | 浏览器兼容的本地文件 | npm `io` + 支持 URL/HTTPS |
-| **连接地址模式** | `host:port` 组合 | `host:port` 组合 | `host:port` 或完整 `url` |
-| **核心偏重** | 双轨并行 | 双轨，认证流程微调 | **明确偏重游戏云** |
-| **认证流程** | domain 路由 + 微信 | openid 路由 + bxs 模式 | 简化，移除微信 OpenId 转换 |
-| **文件数量** | index + authConn + gameConn | index + authConn + gameConn + socket.io.min | **仅 index.js（Remote 类）** |
-
-## 结论
-
-项目最初（V6）是**同时兼容游戏连接器和区块链连接器**的双轨设计，通过 `toolkit.conn` 和 `toolkit.gameconn` 分别提供两个独立的连接器实例。
-
-**V7 是一个过渡版本**，主要解决两类兼容问题：
-1. **浏览器环境兼容**：引入本地 socket.io 文件替代 npm 包的动态加载
-2. **Node.js OpenSSL 3.0 兼容**：build 命令中增加 `--openssl-legacy-provider`
-
-**V8 是一次彻底的重构**，明确了项目的定位调整：
-1. 将双连接器合并为单一 `Remote` 类
-2. **物理删除 `authConn.js`（全节点/区块链连接器）**，大量注释/删除区块链相关的加密签名工具函数
-3. 新增 HTTPS/WSS 的 URL 模式支持，适配现代部署场景（CDN、反向代理）
-4. 简化认证流程，移除微信 OpenId 转换逻辑
-
-整个项目从"通用连接器工具箱"演变为**专注于游戏云连接**的轻量级 RPC 客户端。

package/test/game/kow.js

@@ -1,43 +0,0 @@
-/**
- * 联机单元测试：游戏登录测试流程
- */
-
-//连接配置信息
-const config = {
-  UrlHead: "http",              //协议选择: http/https
-  webserver: { 
-      "host": "127.0.0.1",      //远程主机地址
-      "port": 9901              //远程主机端口
-  },
-  logicserver: {},
-  oemInfo: {                    //模拟用户信息
-    domain: 'CoreOfKow',        //指定访问的逻辑服务器类型
-    openid: `bxs.15699999936`,  //用户标识
-    token: '',                  //用户令牌，由920客户端向920服务端索取并填充于此
-  },
-}
-
-//长连接中，下行通告的类型定义
-const NotifyType = {
-  action: 1,          //体力数值推送
-};  
-
-//引入长连接组件
-let gameconn = require('../../index');
-let connector = new gameconn(config)
-  .setFetch(require('node-fetch'));      //设置node服务端环境下兼容的fetch函数，**注意只在node服务端环境下需要，浏览器环境中系统自带 fetch 函数**
-
-connector.setmode(connector.CommMode.ws).watch(msg => {
-    console.log('收到下行消息', msg);
-}, NotifyType.action);
-
-(async function() {
-  console.log('start login...');
-  try {
-    let ret = await connector.login(config.oemInfo);
-    console.log('end login...');
-    console.log(config.oemInfo, ret);
-  } catch(e) {
-    console.log(e);
-  }
-})();