wowok 2.1.9 → 2.1.12

package/dist/cjs/w/messenger/session.js

@@ -1,418 +1,414 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var session_exports = {};
-__export(session_exports, {
-  MessengerSession: () => MessengerSession
-});
-module.exports = __toCommonJS(session_exports);
-var import_libsignal_protocol_typescript = require("libsignal-protocol-typescript");
-var import_account = require("../local/account.js");
-var import_storage = require("./storage.js");
-var import_server = require("./server.js");
-var import_crypto = require("./crypto.js");
-var import_types = require("./types.js");
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessengerSession = void 0;
+/**
+ * Messenger 会话管理模块
+ *
+ * 基于 Signal Protocol 的双棘轮算法实现端到端加密
+ * 负责：
+ * 1. 身份密钥管理（与 wowok 账户体系集成）
+ * 2. 会话建立和维护
+ * 3. 消息加密和解密
+ */
+const libsignal_protocol_typescript_1 = require("libsignal-protocol-typescript");
+const account_js_1 = require("../local/account.js");
+const storage_js_1 = require("./storage.js");
+const server_js_1 = require("./server.js");
+const crypto_js_1 = require("./crypto.js");
+const types_js_1 = require("./types.js");
 class MessengerSession {
-  constructor(userAddress, config) {
-    __publicField(this, "store");
-    __publicField(this, "serverClient");
-    __publicField(this, "config");
-    __publicField(this, "identity", null);
-    this.store = new import_storage.SignalProtocolStorage(userAddress);
-    this.config = { ...import_types.DEFAULT_MESSENGER_CONFIG, ...config };
-    this.serverClient = new import_server.MessengerServerClient(this.config);
-  }
-  /**
-   * 获取或创建本地身份
-   *
-   * 从 wowok 账户的 ED25519 私钥确定性派生 X25519 密钥对，
-   * 确保恢复钱包后加密身份不变。
-   */
-  async ensureIdentity(userAddress) {
-    if (this.identity) {
-      return this.identity;
+    store;
+    serverClient;
+    config;
+    identity = null;
+    constructor(userAddress, config) {
+        this.store = new storage_js_1.SignalProtocolStorage(userAddress);
+        this.config = { ...types_js_1.DEFAULT_MESSENGER_CONFIG, ...config };
+        this.serverClient = new server_js_1.MessengerServerClient(this.config);
     }
-    const existingSignalIdentity = await this.store.getIdentityKeyPair();
-    const existingRegId = await this.store.getLocalRegistrationId();
-    if (existingSignalIdentity && existingRegId) {
-      const x25519PrivateKey = new Uint8Array(
-        existingSignalIdentity.privKey
-      );
-      const xed255192 = (0, import_crypto.recoverXed25519FromX25519PrivateKey)(x25519PrivateKey);
-      this.identity = {
-        xed25519: xed255192,
-        signalIdentity: existingSignalIdentity,
-        registrationId: existingRegId
-      };
-      return this.identity;
-    }
-    if (!userAddress) {
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.IDENTITY_NOT_FOUND,
-        "userAddress is required to derive identity"
-      );
-    }
-    const { privateKey, publicKey } = await import_account.Account.Instance().deriveX25519KeyPair(userAddress);
-    const registrationId = this.deriveRegistrationId(publicKey);
-    const prefixedPublicKey = new Uint8Array(33);
-    prefixedPublicKey[0] = 5;
-    prefixedPublicKey.set(publicKey, 1);
-    const signalIdentity = {
-      privKey: privateKey.buffer.slice(
-        privateKey.byteOffset,
-        privateKey.byteOffset + privateKey.byteLength
-      ),
-      pubKey: prefixedPublicKey.buffer.slice(
-        prefixedPublicKey.byteOffset,
-        prefixedPublicKey.byteOffset + prefixedPublicKey.byteLength
-      )
-    };
-    await this.store.setIdentity(signalIdentity, registrationId);
-    const xed25519 = (0, import_crypto.recoverXed25519FromX25519PrivateKey)(privateKey);
-    this.identity = {
-      xed25519,
-      signalIdentity,
-      registrationId
-    };
-    return this.identity;
-  }
-  /**
-   * 从公钥确定性派生注册 ID
-   * 确保同一账户的注册 ID 始终相同
-   */
-  deriveRegistrationId(publicKey) {
-    const id = publicKey[0] << 8 | publicKey[1];
-    return id === 0 ? 1 : id;
-  }
-  /**
-   * 注册设备到服务器
-   */
-  async registerDevice(userAddress) {
-    const identity = await this.ensureIdentity(userAddress);
-    const prekeys = await this.generatePreKeyBatch(
-      this.config.prekey_count
-    );
-    const prefixedIdentityKey = (0, import_crypto.arrayBufferToUint8Array)(
-      identity.signalIdentity.pubKey
-    );
-    const account = await import_account.Account.Instance().get(userAddress, false);
-    if (!account?.pubkey) {
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.IDENTITY_NOT_FOUND,
-        `Account not found for ${userAddress}`
-      );
-    }
-    const timestamp = Date.now();
-    const nonce = this.generateNonce();
-    const message = `register:${account.pubkey}:${timestamp}:${nonce}`;
-    const signResult = await import_account.Account.Instance().signData(
-      userAddress,
-      message
-    );
-    const signature = Buffer.from(signResult.signature.slice(2), "hex");
-    const registerRequest = {
-      userAddress,
-      deviceId: import_types.DEFAULT_DEVICE_ID,
-      registrationId: identity.registrationId,
-      identityKey: (0, import_crypto.bytesToBase64)(prefixedIdentityKey),
-      prekeys,
-      publicKey: account.pubkey,
-      signatureScheme: "ED25519",
-      signature: (0, import_crypto.bytesToBase64)(signature),
-      timestamp,
-      nonce
-    };
-    await this.serverClient.registerDevice(registerRequest);
-  }
-  /**
-   * 生成预密钥批次
-   */
-  async generatePreKeyBatch(count) {
-    if (count <= 0) return [];
-    const identity = await this.ensureIdentity();
-    const meta = await this.store.getMeta();
-    let nextPreKeyId = meta.nextPreKeyId || 1;
-    const prekeys = [];
-    for (let i = 0; i < count; i++) {
-      const keyId = nextPreKeyId + i;
-      const signedPreKey = await import_libsignal_protocol_typescript.KeyHelper.generateSignedPreKey(
-        identity.signalIdentity,
-        keyId
-      );
-      const prekeyPublicKey = (0, import_crypto.arrayBufferToUint8Array)(
-        signedPreKey.keyPair.pubKey
-      );
-      const prefixedPublicKey = prekeyPublicKey;
-      const signature = (0, import_crypto.arrayBufferToUint8Array)(signedPreKey.signature);
-      await this.store.storePreKey(keyId, signedPreKey.keyPair);
-      await this.store.storeSignedPreKey(keyId, signedPreKey.keyPair);
-      prekeys.push({
-        keyId,
-        publicKey: (0, import_crypto.bytesToBase64)(prefixedPublicKey),
-        signature: (0, import_crypto.bytesToBase64)(signature)
-      });
+    /**
+     * 获取或创建本地身份
+     *
+     * 从 wowok 账户的 ED25519 私钥确定性派生 X25519 密钥对，
+     * 确保恢复钱包后加密身份不变。
+     */
+    async ensureIdentity(userAddress) {
+        if (this.identity) {
+            return this.identity;
+        }
+        // 尝试从存储加载
+        const existingSignalIdentity = await this.store.getIdentityKeyPair();
+        const existingRegId = await this.store.getLocalRegistrationId();
+        if (existingSignalIdentity && existingRegId) {
+            const x25519PrivateKey = new Uint8Array(existingSignalIdentity.privKey);
+            const xed25519 = (0, crypto_js_1.recoverXed25519FromX25519PrivateKey)(x25519PrivateKey);
+            this.identity = {
+                xed25519,
+                signalIdentity: existingSignalIdentity,
+                registrationId: existingRegId,
+            };
+            return this.identity;
+        }
+        // 从 ED25519 私钥确定性派生 X25519 密钥对
+        if (!userAddress) {
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.IDENTITY_NOT_FOUND, "userAddress is required to derive identity");
+        }
+        // 从 Account 派生 X25519 密钥对
+        const { privateKey, publicKey } = await account_js_1.Account.Instance().deriveX25519KeyPair(userAddress);
+        // 生成注册 ID（可以从公钥派生，确保确定性）
+        const registrationId = this.deriveRegistrationId(publicKey);
+        // 转换为 Signal Protocol 格式
+        // Signal Protocol 要求公钥带 0x05 前缀（33字节），私钥32字节
+        const prefixedPublicKey = new Uint8Array(33);
+        prefixedPublicKey[0] = 0x05; // Signal Protocol 标准前缀
+        prefixedPublicKey.set(publicKey, 1);
+        const signalIdentity = {
+            privKey: privateKey.buffer.slice(privateKey.byteOffset, privateKey.byteOffset + privateKey.byteLength),
+            pubKey: prefixedPublicKey.buffer.slice(prefixedPublicKey.byteOffset, prefixedPublicKey.byteOffset + prefixedPublicKey.byteLength),
+        };
+        await this.store.setIdentity(signalIdentity, registrationId);
+        const xed25519 = (0, crypto_js_1.recoverXed25519FromX25519PrivateKey)(privateKey);
+        this.identity = {
+            xed25519,
+            signalIdentity,
+            registrationId,
+        };
+        return this.identity;
     }
-    nextPreKeyId += count;
-    await this.store.setMeta({ nextPreKeyId });
-    return prekeys;
-  }
-  /**
-   * 确保服务器上有足够可用的预密钥
-   *
-   * 逻辑：查询服务器当前预密钥数量，按需生成并上传，补充到服务器最大容量
-   */
-  async ensurePreKeys(userAddress, force = false) {
-    const status = await this.serverClient.getPrekeyStatus(userAddress);
-    if (!force && status.currentCount >= status.maxAllowed) {
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.PREKEYS_FULL,
-        `Prekeys already full on server: ${status.currentCount}/${status.maxAllowed}`
-      );
+    /**
+     * 从公钥确定性派生注册 ID
+     * 确保同一账户的注册 ID 始终相同
+     */
+    deriveRegistrationId(publicKey) {
+        // 取公钥前 2 字节作为注册 ID（范围 0-65535）
+        // 确保不为 0（Signal Protocol 要求）
+        const id = (publicKey[0] << 8) | publicKey[1];
+        return id === 0 ? 1 : id;
     }
-    const needCount = status.maxAllowed - status.currentCount;
-    if (needCount <= 0) {
-      return;
+    /**
+     * 注册设备到服务器
+     */
+    async registerDevice(userAddress) {
+        const identity = await this.ensureIdentity(userAddress);
+        // 首次注册时上传最大数量的预密钥
+        const prekeys = await this.generatePreKeyBatch(this.config.prekey_count);
+        // 注意：KeyHelper.generateIdentityKeyPair 返回的 identityKey 已经带有 0x05 前缀了
+        // 不要再次 encodeX25519PublicKey，否则会有双重前缀！
+        const prefixedIdentityKey = (0, crypto_js_1.arrayBufferToUint8Array)(identity.signalIdentity.pubKey);
+        // 获取账户信息用于签名
+        const account = await account_js_1.Account.Instance().get(userAddress, false);
+        if (!account?.pubkey) {
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.IDENTITY_NOT_FOUND, `Account not found for ${userAddress}`);
+        }
+        // 构造签名
+        const timestamp = Date.now();
+        const nonce = this.generateNonce();
+        const message = `register:${account.pubkey}:${timestamp}:${nonce}`;
+        const signResult = await account_js_1.Account.Instance().signData(userAddress, message);
+        const signature = Buffer.from(signResult.signature.slice(2), "hex");
+        const registerRequest = {
+            userAddress,
+            deviceId: types_js_1.DEFAULT_DEVICE_ID,
+            registrationId: identity.registrationId,
+            identityKey: (0, crypto_js_1.bytesToBase64)(prefixedIdentityKey),
+            prekeys,
+            publicKey: account.pubkey,
+            signatureScheme: "ED25519",
+            signature: (0, crypto_js_1.bytesToBase64)(signature),
+            timestamp,
+            nonce,
+        };
+        await this.serverClient.registerDevice(registerRequest);
     }
-    await this.ensureIdentity(userAddress);
-    const prekeys = await this.generatePreKeyBatch(needCount);
-    const account = await import_account.Account.Instance().get(userAddress, false);
-    if (!account?.pubkey) {
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.IDENTITY_NOT_FOUND,
-        `Account not found for ${userAddress}`
-      );
+    /**
+     * 生成预密钥批次
+     */
+    async generatePreKeyBatch(count) {
+        if (count <= 0)
+            return [];
+        const identity = await this.ensureIdentity();
+        const meta = await this.store.getMeta();
+        let nextPreKeyId = meta.nextPreKeyId || 1;
+        const prekeys = [];
+        for (let i = 0; i < count; i++) {
+            const keyId = nextPreKeyId + i;
+            // 使用双棘轮库的 KeyHelper.generateSignedPreKey 生成带 X25519 签名的 signed prekey
+            const signedPreKey = await libsignal_protocol_typescript_1.KeyHelper.generateSignedPreKey(identity.signalIdentity, keyId);
+            const prekeyPublicKey = (0, crypto_js_1.arrayBufferToUint8Array)(signedPreKey.keyPair.pubKey);
+            // 注意：KeyHelper.generateSignedPreKey 返回的 prekey 已经带有 0x05 前缀了
+            // 不要再次 encodeX25519PublicKey，否则会有双重前缀！
+            const prefixedPublicKey = prekeyPublicKey;
+            // 双棘轮库已经生成了 X25519 签名，直接使用
+            const signature = (0, crypto_js_1.arrayBufferToUint8Array)(signedPreKey.signature);
+            await this.store.storePreKey(keyId, signedPreKey.keyPair);
+            await this.store.storeSignedPreKey(keyId, signedPreKey.keyPair);
+            prekeys.push({
+                keyId,
+                publicKey: (0, crypto_js_1.bytesToBase64)(prefixedPublicKey),
+                signature: (0, crypto_js_1.bytesToBase64)(signature),
+            });
+        }
+        nextPreKeyId += count;
+        await this.store.setMeta({ nextPreKeyId });
+        return prekeys;
     }
-    const timestamp = Date.now();
-    const nonce = this.generateNonce();
-    const message = `upload_prekeys:${account.pubkey}:${timestamp}:${nonce}`;
-    const signResult = await import_account.Account.Instance().signData(
-      userAddress,
-      message
-    );
-    const signature = Buffer.from(signResult.signature.slice(2), "hex");
-    await this.serverClient.uploadPreKeys({
-      userAddress,
-      prekeys,
-      publicKey: account.pubkey,
-      signatureScheme: "ED25519",
-      signature: (0, import_crypto.bytesToBase64)(signature),
-      timestamp,
-      nonce
-    });
-  }
-  /**
-   * 生成随机 nonce
-   */
-  generateNonce() {
-    const array = new Uint8Array(16);
-    crypto.getRandomValues(array);
-    return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join(
-      ""
-    );
-  }
-  /**
-   * 建立与对方的会话
-   */
-  async establishSession(myAddress, peerAddress, peerDeviceId = import_types.DEFAULT_DEVICE_ID) {
-    const protocolAddress = new import_libsignal_protocol_typescript.SignalProtocolAddress(
-      peerAddress,
-      peerDeviceId
-    );
-    const existingSession = await this.store.loadSession(
-      protocolAddress.toString()
-    );
-    if (existingSession) {
-      return;
+    /**
+     * 确保服务器上有足够可用的预密钥
+     *
+     * 逻辑：查询服务器当前预密钥数量，按需生成并上传，补充到服务器最大容量
+     */
+    async ensurePreKeys(userAddress, force = false) {
+        // 1. 查询服务器当前预密钥状态
+        const status = await this.serverClient.getPrekeyStatus(userAddress);
+        // 2. 如果服务器已满且非强制模式，直接返回
+        if (!force && status.currentCount >= status.maxAllowed) {
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.PREKEYS_FULL, `Prekeys already full on server: ${status.currentCount}/${status.maxAllowed}`);
+        }
+        // 3. 计算需要补充的数量
+        const needCount = status.maxAllowed - status.currentCount;
+        if (needCount <= 0) {
+            /*console.log(
+                `No need to refill prekeys, server has ${status.currentCount}/${status.maxAllowed}`,
+            );*/
+            return;
+        }
+        /*console.log(
+            `Refilling prekeys: server has ${status.currentCount}/${status.maxAllowed}, need ${needCount}`,
+        );*/
+        // 4. 确保身份已初始化
+        await this.ensureIdentity(userAddress);
+        // 5. 生成所需数量的预密钥
+        const prekeys = await this.generatePreKeyBatch(needCount);
+        // 6. 获取账户信息用于签名
+        const account = await account_js_1.Account.Instance().get(userAddress, false);
+        if (!account?.pubkey) {
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.IDENTITY_NOT_FOUND, `Account not found for ${userAddress}`);
+        }
+        // 7. 构造上传请求（包含签名）
+        // 8. 生成签名
+        const timestamp = Date.now();
+        const nonce = this.generateNonce();
+        const message = `upload_prekeys:${account.pubkey}:${timestamp}:${nonce}`;
+        const signResult = await account_js_1.Account.Instance().signData(userAddress, message);
+        const signature = Buffer.from(signResult.signature.slice(2), "hex");
+        // 9. 上传预密钥（服务器会自动丢弃超过最大数量的部分）
+        await this.serverClient.uploadPreKeys({
+            userAddress,
+            prekeys,
+            publicKey: account.pubkey,
+            signatureScheme: "ED25519",
+            signature: (0, crypto_js_1.bytesToBase64)(signature),
+            timestamp,
+            nonce,
+        });
     }
-    const account = await import_account.Account.Instance().get(myAddress, false);
-    if (!account?.pubkey) {
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.IDENTITY_NOT_FOUND,
-        `Account not found for ${myAddress}`
-      );
+    /**
+     * 生成随机 nonce
+     */
+    generateNonce() {
+        const array = new Uint8Array(16);
+        crypto.getRandomValues(array);
+        return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
     }
-    const timestamp = Date.now();
-    const nonce = this.generateNonce();
-    const publicKeyWithFlag = account.pubkey;
-    const message = `get_bundle:${myAddress}:${timestamp}:${nonce}`;
-    const signResult = await import_account.Account.Instance().signData(
-      myAddress,
-      message
-    );
-    const signature = Buffer.from(signResult.signature.slice(2), "hex");
-    const remoteBundle = await this.serverClient.fetchRemoteBundle(
-      peerAddress,
-      myAddress,
-      publicKeyWithFlag,
-      {
-        signatureScheme: "ED25519",
-        signature: (0, import_crypto.bytesToBase64)(new Uint8Array(signature)),
-        timestamp,
-        nonce
-      },
-      peerDeviceId
-    );
-    const preferredPreKey = remoteBundle.signedPrekey;
-    if (!preferredPreKey) {
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.IDENTITY_NOT_FOUND,
-        `No signed prekey available for ${peerAddress}`
-      );
+    /**
+     * 建立与对方的会话
+     */
+    async establishSession(myAddress, peerAddress, peerDeviceId = types_js_1.DEFAULT_DEVICE_ID) {
+        const protocolAddress = new libsignal_protocol_typescript_1.SignalProtocolAddress(peerAddress, peerDeviceId);
+        // 检查是否已有会话
+        const existingSession = await this.store.loadSession(protocolAddress.toString());
+        if (existingSession) {
+            return;
+        }
+        // 获取账户信息以生成签名
+        const account = await account_js_1.Account.Instance().get(myAddress, false);
+        if (!account?.pubkey) {
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.IDENTITY_NOT_FOUND, `Account not found for ${myAddress}`);
+        }
+        // 构造签名
+        const timestamp = Date.now();
+        const nonce = this.generateNonce();
+        const publicKeyWithFlag = account.pubkey;
+        // 签名格式: get_bundle:{address}:{timestamp}:{nonce}
+        const message = `get_bundle:${myAddress}:${timestamp}:${nonce}`;
+        const signResult = await account_js_1.Account.Instance().signData(myAddress, message);
+        const signature = Buffer.from(signResult.signature.slice(2), "hex");
+        // 获取对方密钥包（带签名验证）
+        const remoteBundle = await this.serverClient.fetchRemoteBundle(peerAddress, myAddress, publicKeyWithFlag, {
+            signatureScheme: "ED25519",
+            signature: (0, crypto_js_1.bytesToBase64)(new Uint8Array(signature)),
+            timestamp,
+            nonce,
+        }, peerDeviceId);
+        const preferredPreKey = remoteBundle.signedPrekey;
+        if (!preferredPreKey) {
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.IDENTITY_NOT_FOUND, `No signed prekey available for ${peerAddress}`);
+        }
+        // 转换为 Signal Protocol 设备格式
+        const identityKeyBytes = (0, crypto_js_1.base64ToBytes)(remoteBundle.identityKey);
+        const preKeyPublicBytes = (0, crypto_js_1.base64ToBytes)(preferredPreKey.publicKey);
+        const signatureBytes = (0, crypto_js_1.base64ToBytes)(preferredPreKey.signature);
+        // 注意：identityKey 和 signedPreKey.publicKey 都不要 decode 去掉前缀！
+        // 因为当初签名时用的就是带 0x05 前缀的原始公钥！
+        const originalIdentityKeyWithPrefix = new Uint8Array(identityKeyBytes);
+        const originalPreKeyWithPrefix = new Uint8Array(preKeyPublicBytes);
+        const device = {
+            registrationId: remoteBundle.registrationId,
+            identityKey: originalIdentityKeyWithPrefix.buffer.slice(originalIdentityKeyWithPrefix.byteOffset, originalIdentityKeyWithPrefix.byteOffset +
+                originalIdentityKeyWithPrefix.byteLength),
+            signedPreKey: {
+                keyId: preferredPreKey.keyId,
+                publicKey: originalPreKeyWithPrefix.buffer.slice(originalPreKeyWithPrefix.byteOffset, originalPreKeyWithPrefix.byteOffset +
+                    originalPreKeyWithPrefix.byteLength),
+                signature: new Uint8Array(signatureBytes).buffer.slice(signatureBytes.byteOffset, signatureBytes.byteOffset + signatureBytes.byteLength),
+            },
+            // 服务器只提供 signedPreKey，没有单独的 one-time preKey
+            // 这是可以的，Signal Protocol 支持仅使用 signedPreKey 建立会话
+            preKey: undefined,
+        };
+        // 建立会话
+        const builder = new libsignal_protocol_typescript_1.SessionBuilder(this.store, protocolAddress);
+        await builder.processPreKey(device);
+        // 显式存储对方的身份密钥，以便后续解密对方的回复
+        // 使用 protocolAddress.toString() 作为键（包含 deviceId）
+        await this.store.saveIdentity(protocolAddress.toString(), device.identityKey);
     }
-    const identityKeyBytes = (0, import_crypto.base64ToBytes)(remoteBundle.identityKey);
-    const preKeyPublicBytes = (0, import_crypto.base64ToBytes)(preferredPreKey.publicKey);
-    const signatureBytes = (0, import_crypto.base64ToBytes)(preferredPreKey.signature);
-    const originalIdentityKeyWithPrefix = new Uint8Array(identityKeyBytes);
-    const originalPreKeyWithPrefix = new Uint8Array(preKeyPublicBytes);
-    const device = {
-      registrationId: remoteBundle.registrationId,
-      identityKey: originalIdentityKeyWithPrefix.buffer.slice(
-        originalIdentityKeyWithPrefix.byteOffset,
-        originalIdentityKeyWithPrefix.byteOffset + originalIdentityKeyWithPrefix.byteLength
-      ),
-      signedPreKey: {
-        keyId: preferredPreKey.keyId,
-        publicKey: originalPreKeyWithPrefix.buffer.slice(
-          originalPreKeyWithPrefix.byteOffset,
-          originalPreKeyWithPrefix.byteOffset + originalPreKeyWithPrefix.byteLength
-        ),
-        signature: new Uint8Array(signatureBytes).buffer.slice(
-          signatureBytes.byteOffset,
-          signatureBytes.byteOffset + signatureBytes.byteLength
-        )
-      },
-      // 服务器只提供 signedPreKey，没有单独的 one-time preKey
-      // 这是可以的，Signal Protocol 支持仅使用 signedPreKey 建立会话
-      preKey: void 0
-    };
-    const builder = new import_libsignal_protocol_typescript.SessionBuilder(this.store, protocolAddress);
-    await builder.processPreKey(device);
-    await this.store.saveIdentity(
-      protocolAddress.toString(),
-      device.identityKey
-    );
-  }
-  /**
-   * 加密消息
-   * @param myAddress 发送方地址
-   * @param peerAddress 接收方地址
-   * @param plaintext 明文
-   * @param peerDeviceId 设备ID
-   * @returns 加密后的消息（type 表示底层 Signal Protocol 消息类型：3=PreKeyMessage, 1=WhisperMessage）
-   */
-  async encryptMessage(myAddress, peerAddress, plaintext, peerDeviceId = import_types.DEFAULT_DEVICE_ID) {
-    const protocolAddress = new import_libsignal_protocol_typescript.SignalProtocolAddress(
-      peerAddress,
-      peerDeviceId
-    );
-    const sessionKey = protocolAddress.toString();
-    const existingSession = await this.store.loadSession(sessionKey);
-    const isNewSession = !existingSession;
-    if (isNewSession) {
-      await this.establishSession(myAddress, peerAddress, peerDeviceId);
+    /**
+     * 加密消息
+     * @param myAddress 发送方地址
+     * @param peerAddress 接收方地址
+     * @param plaintext 明文
+     * @param peerDeviceId 设备ID
+     * @returns 加密后的消息（type 表示底层 Signal Protocol 消息类型：3=PreKeyMessage, 1=WhisperMessage）
+     */
+    async encryptMessage(myAddress, peerAddress, plaintext, peerDeviceId = types_js_1.DEFAULT_DEVICE_ID) {
+        const protocolAddress = new libsignal_protocol_typescript_1.SignalProtocolAddress(peerAddress, peerDeviceId);
+        // 检查是否已有会话（用于确定底层消息类型）
+        const sessionKey = protocolAddress.toString();
+        const existingSession = await this.store.loadSession(sessionKey);
+        const isNewSession = !existingSession;
+        // 只有在新会话时才建立会话，避免重置已存在的会话状态
+        if (isNewSession) {
+            await this.establishSession(myAddress, peerAddress, peerDeviceId);
+        }
+        const cipher = new libsignal_protocol_typescript_1.SessionCipher(this.store, protocolAddress);
+        const encoder = new TextEncoder();
+        const cipherMessage = await cipher.encrypt(encoder.encode(plaintext).buffer);
+        // Convert body to ArrayBuffer if it's a string
+        let bodyBuffer;
+        if (typeof cipherMessage.body === "string") {
+            const bodyBytes = Buffer.from(cipherMessage.body, "binary");
+            bodyBuffer = new Uint8Array(bodyBytes).buffer;
+        }
+        else if (cipherMessage.body) {
+            bodyBuffer = cipherMessage.body;
+        }
+        else {
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.ENCRYPTION_FAILED, "Cipher message body is empty");
+        }
+        // 使用 SessionCipher 返回的消息类型（1 或 3）
+        // SessionCipher 根据 session.pendingPreKey 是否存在来决定消息类型
+        /*const msgType = cipherMessage.type === 3 ? "PREKEY" : "WHISPER";
+        console.log(
+            `[Session Debug] 加密完成: msgType=${msgType}(${cipherMessage.type}), bodyLength=${bodyBuffer.byteLength}, isNewSession=${isNewSession}`,
+        );*/
+        return {
+            type: cipherMessage.type,
+            body: bodyBuffer,
+            registrationId: cipherMessage.registrationId,
+        };
     }
-    const cipher = new import_libsignal_protocol_typescript.SessionCipher(this.store, protocolAddress);
-    const encoder = new TextEncoder();
-    const cipherMessage = await cipher.encrypt(
-      encoder.encode(plaintext).buffer
-    );
-    let bodyBuffer;
-    if (typeof cipherMessage.body === "string") {
-      const bodyBytes = Buffer.from(cipherMessage.body, "binary");
-      bodyBuffer = new Uint8Array(bodyBytes).buffer;
-    } else if (cipherMessage.body) {
-      bodyBuffer = cipherMessage.body;
-    } else {
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.ENCRYPTION_FAILED,
-        "Cipher message body is empty"
-      );
+    /**
+     * 解密消息
+     */
+    async decryptMessage(myAddress, peerAddress, ciphertext, msgType, peerDeviceId = types_js_1.DEFAULT_DEVICE_ID) {
+        const protocolAddress = new libsignal_protocol_typescript_1.SignalProtocolAddress(peerAddress, peerDeviceId);
+        // Signal 协议中，接收方直接使用自己的私钥解密消息
+        // decryptPreKeyWhisperMessage 会自动处理会话建立，不需要预先获取发送方的密钥包
+        // 发送方使用接收方的预密钥公钥加密，接收方使用自己的预密钥私钥解密
+        const cipher = new libsignal_protocol_typescript_1.SessionCipher(this.store, protocolAddress);
+        const decoder = new TextDecoder();
+        // 检查会话状态
+        const sessionKey = protocolAddress.toString();
+        const existingSession = await this.store.loadSession(sessionKey);
+        let plaintextBuffer;
+        const ciphertextArray = new Uint8Array(ciphertext);
+        let ciphertextBinary = "";
+        for (let i = 0; i < ciphertextArray.length; i++) {
+            ciphertextBinary += String.fromCharCode(ciphertextArray[i]);
+        }
+        try {
+            if (msgType === types_js_1.MessageType.PREKEY_MESSAGE) {
+                // 【新增】如果已有会话，说明对方重置了会话，需要删除旧会话
+                if (existingSession) {
+                    await this.store.removeSession(sessionKey);
+                    // 重新创建 cipher（使用更新后的 store）
+                    const newCipher = new libsignal_protocol_typescript_1.SessionCipher(this.store, protocolAddress);
+                    plaintextBuffer =
+                        await newCipher.decryptPreKeyWhisperMessage(ciphertextBinary, "binary");
+                }
+                else {
+                    plaintextBuffer = await cipher.decryptPreKeyWhisperMessage(ciphertextBinary, "binary");
+                }
+            }
+            else {
+                // 解密前检查会话状态
+                /*const sessionBefore = await this.store.loadSession(sessionKey);
+                console.log(
+                    `[Session Debug] 解密前会话状态: ${sessionBefore ? "存在" : "不存在"}`,
+                );*/
+                plaintextBuffer = await cipher.decryptWhisperMessage(ciphertextBinary, "binary");
+                // 解密后检查会话状态
+                /*const sessionAfter = await this.store.loadSession(sessionKey);
+                console.log(
+                    `[Session Debug] 解密后会话状态: ${sessionAfter ? "存在" : "不存在"}`,
+                );*/
+            }
+        }
+        catch (error) {
+            /*console.error(`[Session Debug] 解密失败:`);
+            console.error(
+                `  错误类型: ${error instanceof Error ? error.constructor.name : typeof error}`,
+            );
+            console.error(
+                `  错误消息: ${error instanceof Error ? error.message : String(error)}`,
+            );
+            if (error instanceof Error && error.stack) {
+                console.error(`  堆栈: ${error.stack.split("\n")[0]}`);
+            }
+            console.error(`  上下文:`);
+            console.error(`    - myAddress: ${myAddress}`);
+            console.error(`    - peerAddress: ${peerAddress}`);
+            console.error(
+                `    - msgType: ${msgType} (${msgType === MessageType.PREKEY_MESSAGE ? "PREKEY" : "WHISPER"})`,
+            );
+            console.error(`    - sessionKey: ${sessionKey}`);
+            console.error(
+                `    - existingSession: ${existingSession ? "存在" : "不存在"}`,
+            );
+            console.error(`    - ciphertext.length: ${ciphertext.byteLength}`);
+            */
+            console.log("error:", error);
+            throw error;
+        }
+        return decoder.decode(plaintextBuffer);
     }
-    return {
-      type: cipherMessage.type,
-      body: bodyBuffer,
-      registrationId: cipherMessage.registrationId
-    };
-  }
-  /**
-   * 解密消息
-   */
-  async decryptMessage(myAddress, peerAddress, ciphertext, msgType, peerDeviceId = import_types.DEFAULT_DEVICE_ID) {
-    const protocolAddress = new import_libsignal_protocol_typescript.SignalProtocolAddress(
-      peerAddress,
-      peerDeviceId
-    );
-    const cipher = new import_libsignal_protocol_typescript.SessionCipher(this.store, protocolAddress);
-    const decoder = new TextDecoder();
-    const sessionKey = protocolAddress.toString();
-    const existingSession = await this.store.loadSession(sessionKey);
-    let plaintextBuffer;
-    const ciphertextArray = new Uint8Array(ciphertext);
-    let ciphertextBinary = "";
-    for (let i = 0; i < ciphertextArray.length; i++) {
-      ciphertextBinary += String.fromCharCode(ciphertextArray[i]);
+    /**
+     * 获取本地身份公钥
+     */
+    async getIdentityKey() {
+        const identity = await this.ensureIdentity();
+        return (0, crypto_js_1.bytesToBase64)((0, crypto_js_1.arrayBufferToUint8Array)(identity.signalIdentity.pubKey));
     }
-    try {
-      if (msgType === import_types.MessageType.PREKEY_MESSAGE) {
-        if (existingSession) {
-          await this.store.removeSession(sessionKey);
-          const newCipher = new import_libsignal_protocol_typescript.SessionCipher(
-            this.store,
-            protocolAddress
-          );
-          plaintextBuffer = await newCipher.decryptPreKeyWhisperMessage(
-            ciphertextBinary,
-            "binary"
-          );
-        } else {
-          plaintextBuffer = await cipher.decryptPreKeyWhisperMessage(
-            ciphertextBinary,
-            "binary"
-          );
-        }
-      } else {
-        plaintextBuffer = await cipher.decryptWhisperMessage(
-          ciphertextBinary,
-          "binary"
-        );
-      }
-    } catch (error) {
-      console.log("error:", error);
-      throw error;
+    /**
+     * 获取注册 ID
+     */
+    async getRegistrationId() {
+        const identity = await this.ensureIdentity();
+        return identity.registrationId;
     }
-    return decoder.decode(plaintextBuffer);
-  }
-  /**
-   * 获取本地身份公钥
-   */
-  async getIdentityKey() {
-    const identity = await this.ensureIdentity();
-    return (0, import_crypto.bytesToBase64)(
-      (0, import_crypto.arrayBufferToUint8Array)(identity.signalIdentity.pubKey)
-    );
-  }
-  /**
-   * 获取注册 ID
-   */
-  async getRegistrationId() {
-    const identity = await this.ensureIdentity();
-    return identity.registrationId;
-  }
 }
+exports.MessengerSession = MessengerSession;
+//# sourceMappingURL=session.js.map