wowok 2.1.39 → 2.1.40

package/dist/cjs/w/messenger/crypto.d.ts

@@ -1,121 +1,30 @@
 import type { Xed25519KeyPair } from "./types.js";
-/**
- * 从 X25519 私钥恢复 XEd25519 密钥对
- */
 export declare function recoverXed25519FromX25519PrivateKey(x25519PrivateKey: Uint8Array): Xed25519KeyPair;
-/**
- * 计算 SHA-256 哈希
- */
 export declare function hashSha256(data: Uint8Array): Uint8Array;
-/**
- * 计算消息哈希（用于 Merkle Tree 叶子节点）
- */
 export declare function hashMessage(data: string): string;
-/**
- * 计算明文哈希（用于 Merkle Tree 证明）
- * plaintext_hash = SHA256(plaintext + lastReceivedLeafIndex + client_timestamp + guardAddress + passportAddress)
- *
- * 【注意】顺序必须与服务器端一致：
- * 1. plaintext
- * 2. lastReceivedLeafIndex (if >= 0)
- * 3. clientTimestamp
- * 4. guardAddress (if present)
- * 5. passportAddress (if present)
- */
 export declare function hashPlaintext(plaintext: string, clientTimestamp: number, guardAddress?: string, passportAddress?: string, lastReceivedLeafIndex?: number): string;
-/**
- * 生成随机 nonce
- */
 export declare function generateNonce(): string;
-/**
- * Uint8Array 转 Base64
- */
 export declare function bytesToBase64(bytes: Uint8Array): string;
-/**
- * Base64 转 Uint8Array
- */
 export declare function base64ToBytes(base64: string): Uint8Array;
-/**
- * Uint8Array 转 Hex
- */
 export declare function bytesToHex(bytes: Uint8Array): string;
-/**
- * Hex 转 Uint8Array
- */
 export declare function hexToBytes(hex: string): Uint8Array;
-/**
- * ArrayBuffer 转 Uint8Array
- */
 export declare function arrayBufferToUint8Array(buf: ArrayBuffer): Uint8Array;
-/**
- * Uint8Array 转 ArrayBuffer
- */
 export declare function uint8ArrayToArrayBuffer(arr: Uint8Array): ArrayBuffer;
-/**
- * 比较两个 ArrayBuffer 是否相等
- */
 export declare function bufferEqual(a: ArrayBufferLike, b: ArrayBufferLike): boolean;
-/**
- * 计算 Merkle 叶子哈希（与服务器端 calculate_message_hash 一致）
- * leaf_hash = SHA256(plaintext_hash.as_bytes() + server_timestamp.to_le_bytes())
- */
 export declare function calculateMerkleLeafHash(plaintextHash: string, serverTimestamp: number): string;
-/**
- * 计算两个哈希的父节点哈希
- */
 export declare function merkleHash(left: string, right: string): string;
-/**
- * 计算新的 Merkle Root（与服务器保持一致）
- *
- * 服务器算法：
- * new_root = SHA256(prev_root + leaf_hash + leaf_index_le_bytes)
- *
- * @param prevRoot 前一个 Root（hex 格式，带或不带 0x 前缀）
- * @param leafHash 叶子节点哈希（hex 格式，带或不带 0x 前缀）
- * @param leafIndex 叶子节点索引
- * @returns 新的 Root（带 0x 前缀的 hex）
- */
 export declare function computeNewRoot(prevRoot: string, leafHash: string, leafIndex: number): string;
-/**
- * 验证 Merkle Proof
- */
 export declare function verifyMerkleProof(leafHash: string, proof: {
     root: string;
     siblings: string[];
     indices: number[];
 }): boolean;
-/**
- * Merkle Root 链验证结果
- */
 export interface MerkleChainValidationResult {
     valid: boolean;
     error?: string;
     expectedRoot?: string;
     actualRoot?: string;
 }
-/**
- * 验证 Merkle Root 链的完整性和时序性
- *
- * 客户端使用此函数独立校验消息链的完整性，通过相同的算法核对 Merkle Tree root 的前后关系
- *
- * @param messages 按顺序排列的消息列表（按 leafIndex 排序）
- * @param initialRoot 初始 Root（可选，默认为全0）
- * @returns 验证结果
- *
- * @example
- * ```typescript
- * const messages = [
- *   { leafIndex: 0, prevRoot: "0x00...", newRoot: "0xabc...", plaintextHash: "0x123..." },
- *   { leafIndex: 1, prevRoot: "0xabc...", newRoot: "0xdef...", plaintextHash: "0x456..." },
- * ];
- * const result = verifyMerkleChain(messages);
- * if (result.valid) {
- *   console.log("Merkle 链验证通过");
- * } else {
- *   console.error("验证失败:", result.error);
- * }
- * ```
- */
 export declare function verifyMerkleChain(messages: Array<{
     leafIndex: number;
     prevRoot: string;
@@ -123,154 +32,59 @@ export declare function verifyMerkleChain(messages: Array<{
     plaintextHash: string;
     serverTimestamp: number;
 }>, initialRoot?: string): MerkleChainValidationResult;
-/**
- * 验证单个消息的 Merkle Root 计算
- *
- * 用于验证服务器返回的 Merkle 数据是否正确
- *
- * @param prevRoot 前一个 Root
- * @param newRoot 新的 Root（服务器返回）
- * @param plaintextHash 明文哈希
- * @param serverTimestamp 服务器时间戳
- * @param leafIndex 叶子索引
- * @returns 验证结果
- */
 export declare function verifySingleMerkleRoot(prevRoot: string, newRoot: string, plaintextHash: string, serverTimestamp: number, leafIndex: number): MerkleChainValidationResult;
-/**
- * 消息验证结果
- */
 export interface MessageVerificationResult {
     valid: boolean;
     error?: string;
-    /** 哪一项验证失败 */
     failedCheck?: "merkle" | "plaintext";
 }
-/**
- * 验证消息参数（基于 Message 结构）
- */
 export interface MessageVerificationParams {
-    /** 消息ID（用于错误信息） */
     messageId: string;
-    /** 明文内容 */
     plaintext: string;
-    /** 消息中保存的明文哈希 */
     plaintextHash: string;
-    /** 消息创建时间（createdAt） */
     createdAt: number;
-    /** Guard 地址（可选） */
     guardAddress?: string;
-    /** Passport 地址（可选） */
     passportAddress?: string;
-    /** 最后收到的消息序号（可选） */
     lastReceivedLeafIndex?: number;
-    /** 服务器签名（可选） */
     serverSignature?: string;
-    /** 服务器公钥（可选） */
     serverPublicKey?: string;
-    /** Merkle 元数据（可选，如果提供则验证 Merkle） */
     merkleMetadata?: {
         prevRoot?: string;
         newRoot: string;
-        /** 服务器时间戳（优先使用 timestamp 字段，兼容 serverTimestamp） */
         timestamp?: number;
         serverTimestamp?: number;
         leafIndex: number;
-        /** Merkle proof siblings（服务器拉取消息时不返回） */
         proofSiblings?: string[];
-        /** Merkle proof indices（服务器拉取消息时不返回） */
         proofIndices?: number[];
     };
 }
-/**
- * 通用消息验证函数
- *
- * 基于 Message 结构中保存的数据验证消息的完整性和 Merkle 证明
- *
- * @param params 验证参数
- * @returns 验证结果
- *
- * @example
- * ```typescript
- * const result = verifyMessage({
- *   messageId: "msg-123",
- *   plaintext: "Hello",
- *   plaintextHash: "0xabc...",
- *   createdAt: 1234567890,
- *   guardAddress: "0x...",
- *   passportAddress: "0x...",
- *   merkleMetadata: { ... }
- * });
- *
- * if (!result.valid) {
- *   throw new Error(result.error);
- * }
- * ```
- */
 export declare function verifyMessage(params: MessageVerificationParams): MessageVerificationResult;
-/**
- * 验证 Ed25519 签名（十六进制格式）
- *
- * @param publicKeyHex 公钥（十六进制字符串）
- * @param message 消息内容
- * @param signatureHex 签名（十六进制字符串）
- * @returns 验证结果
- */
 export declare function verifyEd25519Signature(publicKeyHex: string, message: string, signatureHex: string): boolean;
-/**
- * WTS 消息验证参数
- */
 export interface WtsMessageVerificationParams {
-    /** 消息ID */
     id: string;
-    /** 发送方地址 */
     from: string;
-    /** 接收方地址 */
     to: string;
-    /** 明文哈希 */
     plaintextHash: string;
-    /** 客户端时间戳 */
     clientTimestamp: number;
-    /** 服务器时间戳 */
     timestamp: number;
-    /** 叶子索引 */
     leafIndex: number;
-    /** Merkle Root */
     merkleRoot: string;
-    /** 前一个 Merkle Root（可选） */
     prevRoot?: string;
-    /** 服务器签名 */
     serverSignature?: string;
-    /** 服务器公钥 */
     serverPublicKey?: string;
-    /** Guard 地址 */
     guardAddress?: string;
-    /** Passport 地址 */
     passportAddress?: string;
-    /** 最后收到的消息序号（可选） */
     lastReceivedLeafIndex?: number;
-    /** 明文内容（可选，如果提供则验证 plaintextHash） */
     plaintext?: string;
-    /** Merkle Proof（可选，如果提供则验证 Merkle） */
     merkleProof?: {
         siblings: string[];
         indices: number[];
     };
 }
-/**
- * WTS 文件验证结果
- */
 export interface WtsVerificationResult {
     valid: boolean;
     error?: string;
-    /** 验证失败的消息索引 */
     failedMessageIndex?: number;
-    /** 失败原因 */
     failedCheck?: "plaintext" | "merkle" | "chain";
 }
-/**
- * 验证 WTS 文件中的消息
- *
- * @param messages WTS 消息列表（按 leafIndex 排序）
- * @returns 验证结果
- */
 export declare function verifyWtsMessages(messages: WtsMessageVerificationParams[]): WtsVerificationResult;

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

@@ -1,18 +1,6 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Messenger 加密工具模块
- *
- * 基于 Signal Protocol (双棘轮算法) 的端到端加密实现
- * 使用 XEd25519 进行密钥转换，兼容 Ed25519 签名
- */
 import { ed25519, x25519 } from "@noble/curves/ed25519";
 import { sha256 } from "@noble/hashes/sha256";
 import { randomBytes } from "@noble/hashes/utils";
-// ========== 签名与验证（内部函数） ==========
-/**
- * 使用 Ed25519 公钥验证签名（内部使用）
- */
 function verifyEd25519(publicKey, message, signature) {
     try {
         return ed25519.verify(signature, message, publicKey);
@@ -21,10 +9,6 @@ function verifyEd25519(publicKey, message, signature) {
         return false;
     }
 }
-// ========== 密钥生成 ==========
-/**
- * 从 X25519 私钥恢复 XEd25519 密钥对
- */
 export function recoverXed25519FromX25519PrivateKey(x25519PrivateKey) {
     const x25519PublicKey = x25519.getPublicKey(x25519PrivateKey);
     const ed25519PrivateKey = x25519PrivateKey;
@@ -36,97 +20,50 @@ export function recoverXed25519FromX25519PrivateKey(x25519PrivateKey) {
         ed25519PublicKey,
     };
 }
-// ========== 哈希函数 ==========
-/**
- * 计算 SHA-256 哈希
- */
 export function hashSha256(data) {
     return sha256(data);
 }
-/**
- * 计算消息哈希（用于 Merkle Tree 叶子节点）
- */
 export function hashMessage(data) {
     const hash = sha256(new TextEncoder().encode(data));
     return bytesToHex(hash);
 }
-/**
- * 计算明文哈希（用于 Merkle Tree 证明）
- * plaintext_hash = SHA256(plaintext + lastReceivedLeafIndex + client_timestamp + guardAddress + passportAddress)
- *
- * 【注意】顺序必须与服务器端一致：
- * 1. plaintext
- * 2. lastReceivedLeafIndex (if >= 0)
- * 3. clientTimestamp
- * 4. guardAddress (if present)
- * 5. passportAddress (if present)
- */
 export function hashPlaintext(plaintext, clientTimestamp, guardAddress, passportAddress, lastReceivedLeafIndex) {
     let data = plaintext;
-    // 1. 先添加 lastReceivedLeafIndex（如果 >= 0）
     if (lastReceivedLeafIndex !== undefined && lastReceivedLeafIndex >= 0) {
         data += lastReceivedLeafIndex.toString();
     }
-    // 2. 添加 clientTimestamp
     data += clientTimestamp.toString();
-    // 3. 添加 guardAddress（如果有）
     if (guardAddress) {
         data += guardAddress;
     }
-    // 4. 添加 passportAddress（如果有）
     if (passportAddress) {
         data += passportAddress;
     }
     const hash = sha256(new TextEncoder().encode(data));
     return "0x" + bytesToHex(hash);
 }
-// ========== 工具函数 ==========
-/**
- * 生成随机 nonce
- */
 export function generateNonce() {
     return bytesToHex(randomBytes(16));
 }
-/**
- * Uint8Array 转 Base64
- */
 export function bytesToBase64(bytes) {
     return Buffer.from(bytes).toString("base64");
 }
-/**
- * Base64 转 Uint8Array
- */
 export function base64ToBytes(base64) {
     return new Uint8Array(Buffer.from(base64, "base64"));
 }
-/**
- * Uint8Array 转 Hex
- */
 export function bytesToHex(bytes) {
     return Buffer.from(bytes).toString("hex");
 }
-/**
- * Hex 转 Uint8Array
- */
 export function hexToBytes(hex) {
     return new Uint8Array(Buffer.from(hex, "hex"));
 }
-/**
- * ArrayBuffer 转 Uint8Array
- */
 export function arrayBufferToUint8Array(buf) {
     return new Uint8Array(buf);
 }
-/**
- * Uint8Array 转 ArrayBuffer
- */
 export function uint8ArrayToArrayBuffer(arr) {
     const result = arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
     return result;
 }
-/**
- * 比较两个 ArrayBuffer 是否相等
- */
 export function bufferEqual(a, b) {
     if (a.byteLength !== b.byteLength)
         return false;
@@ -138,10 +75,6 @@ export function bufferEqual(a, b) {
     }
     return true;
 }
-/**
- * 计算 Merkle 叶子哈希（与服务器端 calculate_message_hash 一致）
- * leaf_hash = SHA256(plaintext_hash.as_bytes() + server_timestamp.to_le_bytes())
- */
 export function calculateMerkleLeafHash(plaintextHash, serverTimestamp) {
     const plaintextHashBytes = new TextEncoder().encode(plaintextHash);
     const timestampBuffer = new ArrayBuffer(8);
@@ -154,10 +87,6 @@ export function calculateMerkleLeafHash(plaintextHash, serverTimestamp) {
     const hash = sha256(combined);
     return "0x" + bytesToHex(hash);
 }
-// ========== Merkle Tree 工具 ==========
-/**
- * 计算两个哈希的父节点哈希
- */
 export function merkleHash(left, right) {
     const leftBytes = hexToBytes(left.replace(/^0x/, ""));
     const rightBytes = hexToBytes(right.replace(/^0x/, ""));
@@ -166,84 +95,39 @@ export function merkleHash(left, right) {
     combined.set(rightBytes, leftBytes.length);
     return "0x" + bytesToHex(sha256(combined));
 }
-/**
- * 计算新的 Merkle Root（与服务器保持一致）
- *
- * 服务器算法：
- * new_root = SHA256(prev_root + leaf_hash + leaf_index_le_bytes)
- *
- * @param prevRoot 前一个 Root（hex 格式，带或不带 0x 前缀）
- * @param leafHash 叶子节点哈希（hex 格式，带或不带 0x 前缀）
- * @param leafIndex 叶子节点索引
- * @returns 新的 Root（带 0x 前缀的 hex）
- */
 export function computeNewRoot(prevRoot, leafHash, leafIndex) {
-    // 与服务器端一致：直接对 hex 字符串编码（而不是解码 hex）
     const prevRootBytes = new TextEncoder().encode(prevRoot);
     const leafHashBytes = new TextEncoder().encode(leafHash);
-    // leaf_index 使用小端字节序 (u32)
     const leafIndexBuffer = new ArrayBuffer(4);
     const leafIndexView = new DataView(leafIndexBuffer);
-    leafIndexView.setUint32(0, leafIndex, true); // true = little endian
+    leafIndexView.setUint32(0, leafIndex, true);
     const leafIndexBytes = new Uint8Array(leafIndexBuffer);
-    // 组合：prev_root + leaf_hash + leaf_index
     const combined = new Uint8Array(prevRootBytes.length + leafHashBytes.length + leafIndexBytes.length);
     combined.set(prevRootBytes);
     combined.set(leafHashBytes, prevRootBytes.length);
     combined.set(leafIndexBytes, prevRootBytes.length + leafHashBytes.length);
     return "0x" + bytesToHex(sha256(combined));
 }
-/**
- * 验证 Merkle Proof
- */
 export function verifyMerkleProof(leafHash, proof) {
     let current = leafHash;
     for (let i = 0; i < proof.siblings.length; i++) {
         if (proof.indices[i] === 0) {
-            // 当前是左子节点
             current = merkleHash(current, proof.siblings[i]);
         }
         else {
-            // 当前是右子节点
             current = merkleHash(proof.siblings[i], current);
         }
     }
     return current === proof.root;
 }
-/**
- * 验证 Merkle Root 链的完整性和时序性
- *
- * 客户端使用此函数独立校验消息链的完整性，通过相同的算法核对 Merkle Tree root 的前后关系
- *
- * @param messages 按顺序排列的消息列表（按 leafIndex 排序）
- * @param initialRoot 初始 Root（可选，默认为全0）
- * @returns 验证结果
- *
- * @example
- * ```typescript
- * const messages = [
- *   { leafIndex: 0, prevRoot: "0x00...", newRoot: "0xabc...", plaintextHash: "0x123..." },
- *   { leafIndex: 1, prevRoot: "0xabc...", newRoot: "0xdef...", plaintextHash: "0x456..." },
- * ];
- * const result = verifyMerkleChain(messages);
- * if (result.valid) {
- *   console.log("Merkle 链验证通过");
- * } else {
- *   console.error("验证失败:", result.error);
- * }
- * ```
- */
 export function verifyMerkleChain(messages, initialRoot) {
     if (messages.length === 0) {
         return { valid: true };
     }
-    // 按 leafIndex 排序
     const sortedMessages = [...messages].sort((a, b) => a.leafIndex - b.leafIndex);
-    // 初始 Root
     const zeroRoot = initialRoot || "0x" + "0".repeat(64);
     let expectedPrevRoot = zeroRoot;
     for (const msg of sortedMessages) {
-        // 1. 验证 prevRoot 是否匹配预期（链式连续性检查）
         if (msg.prevRoot.toLowerCase() !== expectedPrevRoot.toLowerCase()) {
             return {
                 valid: false,
@@ -252,10 +136,8 @@ export function verifyMerkleChain(messages, initialRoot) {
                 actualRoot: msg.prevRoot,
             };
         }
-        // 2. 复用 verifySingleMerkleRoot 验证单个消息的 Root 计算
         const result = verifySingleMerkleRoot(msg.prevRoot, msg.newRoot, msg.plaintextHash, msg.serverTimestamp, msg.leafIndex);
         if (!result.valid) {
-            // 添加 leafIndex 上下文到错误信息
             return {
                 valid: false,
                 error: `${result.error} at leafIndex ${msg.leafIndex}`,
@@ -263,25 +145,11 @@ export function verifyMerkleChain(messages, initialRoot) {
                 actualRoot: result.actualRoot,
             };
         }
-        // 3. 更新预期的 prevRoot 为当前的 newRoot
         expectedPrevRoot = msg.newRoot;
     }
     return { valid: true };
 }
-/**
- * 验证单个消息的 Merkle Root 计算
- *
- * 用于验证服务器返回的 Merkle 数据是否正确
- *
- * @param prevRoot 前一个 Root
- * @param newRoot 新的 Root（服务器返回）
- * @param plaintextHash 明文哈希
- * @param serverTimestamp 服务器时间戳
- * @param leafIndex 叶子索引
- * @returns 验证结果
- */
 export function verifySingleMerkleRoot(prevRoot, newRoot, plaintextHash, serverTimestamp, leafIndex) {
-    // 验证输入参数是否为空
     if (!prevRoot) {
         return {
             valid: false,
@@ -312,7 +180,6 @@ export function verifySingleMerkleRoot(prevRoot, newRoot, plaintextHash, serverT
             error: "Missing leafIndex",
         };
     }
-    // 计算正确的 leafHash
     const leafHash = calculateMerkleLeafHash(plaintextHash, serverTimestamp);
     const computedRoot = computeNewRoot(prevRoot, leafHash, leafIndex);
     if (computedRoot.toLowerCase() !== newRoot.toLowerCase()) {
@@ -325,37 +192,9 @@ export function verifySingleMerkleRoot(prevRoot, newRoot, plaintextHash, serverT
     }
     return { valid: true };
 }
-/**
- * 通用消息验证函数
- *
- * 基于 Message 结构中保存的数据验证消息的完整性和 Merkle 证明
- *
- * @param params 验证参数
- * @returns 验证结果
- *
- * @example
- * ```typescript
- * const result = verifyMessage({
- *   messageId: "msg-123",
- *   plaintext: "Hello",
- *   plaintextHash: "0xabc...",
- *   createdAt: 1234567890,
- *   guardAddress: "0x...",
- *   passportAddress: "0x...",
- *   merkleMetadata: { ... }
- * });
- *
- * if (!result.valid) {
- *   throw new Error(result.error);
- * }
- * ```
- */
 export function verifyMessage(params) {
     const { messageId, plaintext, plaintextHash, createdAt, guardAddress, passportAddress, lastReceivedLeafIndex, serverSignature, serverPublicKey, merkleMetadata, } = params;
-    // 1. 验证 plaintextHash（本地验证）
-    // 【更新】包含 lastReceivedLeafIndex 在哈希计算中
     const computedPlaintextHash = hashPlaintext(plaintext, createdAt, guardAddress, passportAddress, lastReceivedLeafIndex);
-    // 标准化哈希值（移除 0x 前缀，转小写）
     const normalizeHash = (hash) => {
         return hash.toLowerCase().replace(/^0x/, "");
     };
@@ -366,13 +205,8 @@ export function verifyMessage(params) {
             failedCheck: "plaintext",
         };
     }
-    // 2. 如果提供了 Merkle 元数据，验证 Merkle
     if (merkleMetadata) {
-        // 2.1 验证 Merkle Proof（消息是否在树中）
-        // 注意：服务器拉取消息时不返回 proofSiblings 和 proofIndices
-        // 只有在发送消息时返回的 merkleMetadata 才包含这些字段
         if (merkleMetadata.proofSiblings && merkleMetadata.proofIndices) {
-            // 使用服务器计算的 leaf_hash（确定性推导）
             const leafHash = calculateMerkleLeafHash(plaintextHash, merkleMetadata.serverTimestamp);
             const proofValid = verifyMerkleProof(leafHash, {
                 root: merkleMetadata.newRoot,
@@ -387,8 +221,6 @@ export function verifyMessage(params) {
                 };
             }
         }
-        // 2.2 验证 Root 计算是否正确
-        // 必须使用服务器时间戳进行验证
         const serverTimestamp = merkleMetadata.serverTimestamp;
         if (!serverTimestamp) {
             return {
@@ -413,9 +245,7 @@ export function verifyMessage(params) {
             };
         }
     }
-    // 3. 验证服务器签名（如果提供了签名和公钥）
     if (serverSignature && serverPublicKey) {
-        // 必须使用服务器时间戳进行验证，不能使用客户端时间
         const timestamp = merkleMetadata?.serverTimestamp;
         if (!timestamp) {
             return {
@@ -424,7 +254,6 @@ export function verifyMessage(params) {
                 failedCheck: "merkle",
             };
         }
-        // 验证必需的字段
         if (!merkleMetadata?.newRoot) {
             return {
                 valid: false,
@@ -451,14 +280,6 @@ export function verifyMessage(params) {
     }
     return { valid: true };
 }
-/**
- * 验证 Ed25519 签名（十六进制格式）
- *
- * @param publicKeyHex 公钥（十六进制字符串）
- * @param message 消息内容
- * @param signatureHex 签名（十六进制字符串）
- * @returns 验证结果
- */
 export function verifyEd25519Signature(publicKeyHex, message, signatureHex) {
     try {
         const publicKey = hexToBytes(publicKeyHex.replace("0x", ""));
@@ -470,22 +291,13 @@ export function verifyEd25519Signature(publicKeyHex, message, signatureHex) {
         return false;
     }
 }
-/**
- * 验证 WTS 文件中的消息
- *
- * @param messages WTS 消息列表（按 leafIndex 排序）
- * @returns 验证结果
- */
 export function verifyWtsMessages(messages) {
     if (messages.length === 0) {
         return { valid: true };
     }
-    // 按 leafIndex 排序
     const sortedMessages = [...messages].sort((a, b) => a.leafIndex - b.leafIndex);
-    // 验证每条消息
     for (let i = 0; i < sortedMessages.length; i++) {
         const msg = sortedMessages[i];
-        // 1. 如果提供了明文，验证 plaintextHash
         if (msg.plaintext != null) {
             const computedHash = hashPlaintext(msg.plaintext || "", msg.clientTimestamp, msg.guardAddress, msg.passportAddress, msg.lastReceivedLeafIndex);
             if (computedHash.toLowerCase() !== msg.plaintextHash.toLowerCase()) {
@@ -497,9 +309,7 @@ export function verifyWtsMessages(messages) {
                 };
             }
         }
-        // 2. 如果提供了 Merkle Proof，验证 Merkle
         if (msg.merkleProof) {
-            // 使用服务器计算的 leaf_hash（确定性推导）
             const leafHash = calculateMerkleLeafHash(msg.plaintextHash, msg.timestamp);
             const proofValid = verifyMerkleProof(leafHash, {
                 root: msg.merkleRoot,
@@ -515,9 +325,7 @@ export function verifyWtsMessages(messages) {
                 };
             }
         }
-        // 3. 验证服务器签名（如果提供了签名和公钥）
         if (msg.serverSignature && msg.serverPublicKey) {
-            // 验证必需的字段
             if (!msg.merkleRoot) {
                 return {
                     valid: false,
@@ -554,10 +362,9 @@ export function verifyWtsMessages(messages) {
             }
         }
     }
-    // 4. 验证 Merkle 链的连续性
     const chainResult = verifyMerkleChain(sortedMessages.map((msg) => ({
         leafIndex: msg.leafIndex,
-        prevRoot: msg.merkleRoot, // WTS 中只保存了最终的 merkleRoot
+        prevRoot: msg.merkleRoot,
         newRoot: msg.merkleRoot,
         plaintextHash: msg.plaintextHash,
         serverTimestamp: msg.timestamp,
@@ -571,4 +378,3 @@ export function verifyWtsMessages(messages) {
     }
     return { valid: true };
 }
-//# sourceMappingURL=crypto.js.map