wowok 2.1.39 → 2.1.41

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

@@ -1,574 +1 @@
-// 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);
-    }
-    catch {
-        return false;
-    }
-}
-// ========== 密钥生成 ==========
-/**
- * 从 X25519 私钥恢复 XEd25519 密钥对
- */
-export function recoverXed25519FromX25519PrivateKey(x25519PrivateKey) {
-    const x25519PublicKey = x25519.getPublicKey(x25519PrivateKey);
-    const ed25519PrivateKey = x25519PrivateKey;
-    const ed25519PublicKey = ed25519.getPublicKey(ed25519PrivateKey);
-    return {
-        x25519PublicKey,
-        x25519PrivateKey,
-        ed25519PrivateKey,
-        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;
-    const va = new Uint8Array(a);
-    const vb = new Uint8Array(b);
-    for (let i = 0; i < va.length; i++) {
-        if (va[i] !== vb[i])
-            return false;
-    }
-    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);
-    const timestampView = new DataView(timestampBuffer);
-    timestampView.setBigUint64(0, BigInt(serverTimestamp), true);
-    const timestampBytes = new Uint8Array(timestampBuffer);
-    const combined = new Uint8Array(plaintextHashBytes.length + timestampBytes.length);
-    combined.set(plaintextHashBytes);
-    combined.set(timestampBytes, plaintextHashBytes.length);
-    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/, ""));
-    const combined = new Uint8Array(leftBytes.length + rightBytes.length);
-    combined.set(leftBytes);
-    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
-    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,
-                error: `Root chain broken at leafIndex ${msg.leafIndex}: expected prevRoot ${expectedPrevRoot}, got ${msg.prevRoot}`,
-                expectedRoot: expectedPrevRoot,
-                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}`,
-                expectedRoot: result.expectedRoot,
-                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,
-            error: "Missing prevRoot",
-        };
-    }
-    if (!newRoot) {
-        return {
-            valid: false,
-            error: "Missing newRoot",
-        };
-    }
-    if (!plaintextHash) {
-        return {
-            valid: false,
-            error: "Missing plaintextHash",
-        };
-    }
-    if (serverTimestamp === undefined || serverTimestamp === null) {
-        return {
-            valid: false,
-            error: "Missing serverTimestamp",
-        };
-    }
-    if (leafIndex === undefined || leafIndex === null) {
-        return {
-            valid: false,
-            error: "Missing leafIndex",
-        };
-    }
-    // 计算正确的 leafHash
-    const leafHash = calculateMerkleLeafHash(plaintextHash, serverTimestamp);
-    const computedRoot = computeNewRoot(prevRoot, leafHash, leafIndex);
-    if (computedRoot.toLowerCase() !== newRoot.toLowerCase()) {
-        return {
-            valid: false,
-            error: `Root computation mismatch: expected ${computedRoot}, got ${newRoot}`,
-            expectedRoot: computedRoot,
-            actualRoot: newRoot,
-        };
-    }
-    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/, "");
-    };
-    if (normalizeHash(computedPlaintextHash) !== normalizeHash(plaintextHash)) {
-        return {
-            valid: false,
-            error: `Plaintext hash mismatch for message ${messageId}: expected ${plaintextHash}, got ${computedPlaintextHash}`,
-            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,
-                siblings: merkleMetadata.proofSiblings,
-                indices: merkleMetadata.proofIndices,
-            });
-            if (!proofValid) {
-                return {
-                    valid: false,
-                    error: `Merkle proof verification failed for message ${messageId}`,
-                    failedCheck: "merkle",
-                };
-            }
-        }
-        // 2.2 验证 Root 计算是否正确
-        // 必须使用服务器时间戳进行验证
-        const serverTimestamp = merkleMetadata.serverTimestamp;
-        if (!serverTimestamp) {
-            return {
-                valid: false,
-                error: `Missing server timestamp for Merkle root verification in message ${messageId}`,
-                failedCheck: "merkle",
-            };
-        }
-        if (!merkleMetadata.prevRoot) {
-            return {
-                valid: false,
-                error: `Missing prevRoot for Merkle root verification in message ${messageId}`,
-                failedCheck: "merkle",
-            };
-        }
-        const rootValid = verifySingleMerkleRoot(merkleMetadata.prevRoot, merkleMetadata.newRoot, plaintextHash, serverTimestamp, merkleMetadata.leafIndex);
-        if (!rootValid.valid) {
-            return {
-                valid: false,
-                error: `Merkle root verification failed for message ${messageId}: ${rootValid.error}`,
-                failedCheck: "merkle",
-            };
-        }
-    }
-    // 3. 验证服务器签名（如果提供了签名和公钥）
-    if (serverSignature && serverPublicKey) {
-        // 必须使用服务器时间戳进行验证，不能使用客户端时间
-        const timestamp = merkleMetadata?.serverTimestamp;
-        if (!timestamp) {
-            return {
-                valid: false,
-                error: `Missing server timestamp for signature verification in message ${messageId}`,
-                failedCheck: "merkle",
-            };
-        }
-        // 验证必需的字段
-        if (!merkleMetadata?.newRoot) {
-            return {
-                valid: false,
-                error: `Missing newRoot for signature verification in message ${messageId}`,
-                failedCheck: "merkle",
-            };
-        }
-        if (!merkleMetadata?.prevRoot) {
-            return {
-                valid: false,
-                error: `Missing prevRoot for signature verification in message ${messageId}`,
-                failedCheck: "merkle",
-            };
-        }
-        const signData = `${merkleMetadata.prevRoot}:${merkleMetadata.newRoot}:${timestamp}:${serverPublicKey}`;
-        const signatureValid = verifyEd25519Signature(serverPublicKey, signData, serverSignature);
-        if (!signatureValid) {
-            return {
-                valid: false,
-                error: `Server signature verification failed for message ${messageId}`,
-                failedCheck: "merkle",
-            };
-        }
-    }
-    return { valid: true };
-}
-/**
- * 验证 Ed25519 签名（十六进制格式）
- *
- * @param publicKeyHex 公钥（十六进制字符串）
- * @param message 消息内容
- * @param signatureHex 签名（十六进制字符串）
- * @returns 验证结果
- */
-export function verifyEd25519Signature(publicKeyHex, message, signatureHex) {
-    try {
-        const publicKey = hexToBytes(publicKeyHex.replace("0x", ""));
-        const signature = hexToBytes(signatureHex.replace("0x", ""));
-        const messageBytes = new TextEncoder().encode(message);
-        return verifyEd25519(publicKey, messageBytes, signature);
-    }
-    catch {
-        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()) {
-                return {
-                    valid: false,
-                    error: `Plaintext hash mismatch for message ${msg.id} at index ${i}`,
-                    failedMessageIndex: i,
-                    failedCheck: "plaintext",
-                };
-            }
-        }
-        // 2. 如果提供了 Merkle Proof，验证 Merkle
-        if (msg.merkleProof) {
-            // 使用服务器计算的 leaf_hash（确定性推导）
-            const leafHash = calculateMerkleLeafHash(msg.plaintextHash, msg.timestamp);
-            const proofValid = verifyMerkleProof(leafHash, {
-                root: msg.merkleRoot,
-                siblings: msg.merkleProof.siblings,
-                indices: msg.merkleProof.indices,
-            });
-            if (!proofValid) {
-                return {
-                    valid: false,
-                    error: `Merkle proof verification failed for message ${msg.id} at index ${i}`,
-                    failedMessageIndex: i,
-                    failedCheck: "merkle",
-                };
-            }
-        }
-        // 3. 验证服务器签名（如果提供了签名和公钥）
-        if (msg.serverSignature && msg.serverPublicKey) {
-            // 验证必需的字段
-            if (!msg.merkleRoot) {
-                return {
-                    valid: false,
-                    error: `Missing merkleRoot for message ${msg.id} at index ${i}`,
-                    failedMessageIndex: i,
-                    failedCheck: "merkle",
-                };
-            }
-            if (!msg.timestamp) {
-                return {
-                    valid: false,
-                    error: `Missing timestamp for message ${msg.id} at index ${i}`,
-                    failedMessageIndex: i,
-                    failedCheck: "merkle",
-                };
-            }
-            if (!msg.prevRoot) {
-                return {
-                    valid: false,
-                    error: `Missing prevRoot for message ${msg.id} at index ${i}`,
-                    failedMessageIndex: i,
-                    failedCheck: "merkle",
-                };
-            }
-            const signData = `${msg.prevRoot}:${msg.merkleRoot}:${msg.timestamp}:${msg.serverPublicKey}`;
-            const signatureValid = verifyEd25519Signature(msg.serverPublicKey, signData, msg.serverSignature);
-            if (!signatureValid) {
-                return {
-                    valid: false,
-                    error: `Server signature verification failed for message ${msg.id} at index ${i}`,
-                    failedMessageIndex: i,
-                    failedCheck: "merkle",
-                };
-            }
-        }
-    }
-    // 4. 验证 Merkle 链的连续性
-    const chainResult = verifyMerkleChain(sortedMessages.map((msg) => ({
-        leafIndex: msg.leafIndex,
-        prevRoot: msg.merkleRoot, // WTS 中只保存了最终的 merkleRoot
-        newRoot: msg.merkleRoot,
-        plaintextHash: msg.plaintextHash,
-        serverTimestamp: msg.timestamp,
-    })));
-    if (!chainResult.valid) {
-        return {
-            valid: false,
-            error: chainResult.error,
-            failedCheck: "chain",
-        };
-    }
-    return { valid: true };
-}
-//# sourceMappingURL=crypto.js.map
+import{ed25519,x25519}from'@noble/curves/ed25519';import{sha256}from'@noble/hashes/sha256';import{randomBytes}from'@noble/hashes/utils';function verifyEd25519(a,b,c){try{return ed25519['verify'](c,b,a);}catch{return![];}}export function recoverXed25519FromX25519PrivateKey(a){const b=x25519['getPublicKey'](a),c=a,d=ed25519['getPublicKey'](c);return{'x25519PublicKey':b,'x25519PrivateKey':a,'ed25519PrivateKey':c,'ed25519PublicKey':d};}export function hashSha256(a){return sha256(a);}export function hashMessage(a){const b=sha256(new TextEncoder()['encode'](a));return bytesToHex(b);}export function hashPlaintext(a,b,c,d,e){let f=a;e!==undefined&&e>=0x0&&(f+=e['toString']());f+=b['toString']();c&&(f+=c);d&&(f+=d);const g=sha256(new TextEncoder()['encode'](f));return'0x'+bytesToHex(g);}export function generateNonce(){return bytesToHex(randomBytes(0x10));}export function bytesToBase64(a){return Buffer['from'](a)['toString']('base64');}export function base64ToBytes(a){return new Uint8Array(Buffer['from'](a,'base64'));}export function bytesToHex(a){return Buffer['from'](a)['toString']('hex');}export function hexToBytes(a){return new Uint8Array(Buffer['from'](a,'hex'));}export function arrayBufferToUint8Array(a){return new Uint8Array(a);}export function uint8ArrayToArrayBuffer(a){const b=a['buffer']['slice'](a['byteOffset'],a['byteOffset']+a['byteLength']);return b;}export function bufferEqual(c,d){if(c['byteLength']!==d['byteLength'])return![];const e=new Uint8Array(c),f=new Uint8Array(d);for(let g=0x0;g<e['length'];g++){if(e[g]!==f[g])return![];}return!![];}export function calculateMerkleLeafHash(a,b){const c=new TextEncoder()['encode'](a),d=new ArrayBuffer(0x8),e=new DataView(d);e['setBigUint64'](0x0,BigInt(b),!![]);const f=new Uint8Array(d),g=new Uint8Array(c['length']+f['length']);g['set'](c),g['set'](f,c['length']);const h=sha256(g);return'0x'+bytesToHex(h);}export function merkleHash(a,b){const c=hexToBytes(a['replace'](/^0x/,'')),d=hexToBytes(b['replace'](/^0x/,'')),e=new Uint8Array(c['length']+d['length']);return e['set'](c),e['set'](d,c['length']),'0x'+bytesToHex(sha256(e));}export function computeNewRoot(a,b,c){const d=new TextEncoder()['encode'](a),e=new TextEncoder()['encode'](b),f=new ArrayBuffer(0x4),g=new DataView(f);g['setUint32'](0x0,c,!![]);const h=new Uint8Array(f),i=new Uint8Array(d['length']+e['length']+h['length']);return i['set'](d),i['set'](e,d['length']),i['set'](h,d['length']+e['length']),'0x'+bytesToHex(sha256(i));}export function verifyMerkleProof(a,b){let c=a;for(let d=0x0;d<b['siblings']['length'];d++){b['indices'][d]===0x0?c=merkleHash(c,b['siblings'][d]):c=merkleHash(b['siblings'][d],c);}return c===b['root'];}export function verifyMerkleChain(a,b){if(a['length']===0x0)return{'valid':!![]};const c=[...a]['sort']((f,g)=>f['leafIndex']-g['leafIndex']),d=b||'0x'+'0'['repeat'](0x40);let e=d;for(const f of c){if(f['prevRoot']['toLowerCase']()!==e['toLowerCase']())return{'valid':![],'error':'Root\x20chain\x20broken\x20at\x20leafIndex\x20'+f['leafIndex']+':\x20expected\x20prevRoot\x20'+e+',\x20got\x20'+f['prevRoot'],'expectedRoot':e,'actualRoot':f['prevRoot']};const g=verifySingleMerkleRoot(f['prevRoot'],f['newRoot'],f['plaintextHash'],f['serverTimestamp'],f['leafIndex']);if(!g['valid'])return{'valid':![],'error':g['error']+'\x20at\x20leafIndex\x20'+f['leafIndex'],'expectedRoot':g['expectedRoot'],'actualRoot':g['actualRoot']};e=f['newRoot'];}return{'valid':!![]};}export function verifySingleMerkleRoot(a,b,c,d,e){if(!a)return{'valid':![],'error':'Missing\x20prevRoot'};if(!b)return{'valid':![],'error':'Missing\x20newRoot'};if(!c)return{'valid':![],'error':'Missing\x20plaintextHash'};if(d===undefined||d===null)return{'valid':![],'error':'Missing\x20serverTimestamp'};if(e===undefined||e===null)return{'valid':![],'error':'Missing\x20leafIndex'};const f=calculateMerkleLeafHash(c,d),g=computeNewRoot(a,f,e);if(g['toLowerCase']()!==b['toLowerCase']())return{'valid':![],'error':'Root\x20computation\x20mismatch:\x20expected\x20'+g+',\x20got\x20'+b,'expectedRoot':g,'actualRoot':b};return{'valid':!![]};}export function verifyMessage(a){const {messageId:b,plaintext:c,plaintextHash:d,createdAt:e,guardAddress:f,passportAddress:g,lastReceivedLeafIndex:h,serverSignature:i,serverPublicKey:j,merkleMetadata:k}=a,l=hashPlaintext(c,e,f,g,h),m=n=>{return n['toLowerCase']()['replace'](/^0x/,'');};if(m(l)!==m(d))return{'valid':![],'error':'Plaintext\x20hash\x20mismatch\x20for\x20message\x20'+b+':\x20expected\x20'+d+',\x20got\x20'+l,'failedCheck':'plaintext'};if(k){if(k['proofSiblings']&&k['proofIndices']){const p=calculateMerkleLeafHash(d,k['serverTimestamp']),q=verifyMerkleProof(p,{'root':k['newRoot'],'siblings':k['proofSiblings'],'indices':k['proofIndices']});if(!q)return{'valid':![],'error':'Merkle\x20proof\x20verification\x20failed\x20for\x20message\x20'+b,'failedCheck':'merkle'};}const n=k['serverTimestamp'];if(!n)return{'valid':![],'error':'Missing\x20server\x20timestamp\x20for\x20Merkle\x20root\x20verification\x20in\x20message\x20'+b,'failedCheck':'merkle'};if(!k['prevRoot'])return{'valid':![],'error':'Missing\x20prevRoot\x20for\x20Merkle\x20root\x20verification\x20in\x20message\x20'+b,'failedCheck':'merkle'};const o=verifySingleMerkleRoot(k['prevRoot'],k['newRoot'],d,n,k['leafIndex']);if(!o['valid'])return{'valid':![],'error':'Merkle\x20root\x20verification\x20failed\x20for\x20message\x20'+b+':\x20'+o['error'],'failedCheck':'merkle'};}if(i&&j){const r=k?.['serverTimestamp'];if(!r)return{'valid':![],'error':'Missing\x20server\x20timestamp\x20for\x20signature\x20verification\x20in\x20message\x20'+b,'failedCheck':'merkle'};if(!k?.['newRoot'])return{'valid':![],'error':'Missing\x20newRoot\x20for\x20signature\x20verification\x20in\x20message\x20'+b,'failedCheck':'merkle'};if(!k?.['prevRoot'])return{'valid':![],'error':'Missing\x20prevRoot\x20for\x20signature\x20verification\x20in\x20message\x20'+b,'failedCheck':'merkle'};const s=k['prevRoot']+':'+k['newRoot']+':'+r+':'+j,t=verifyEd25519Signature(j,s,i);if(!t)return{'valid':![],'error':'Server\x20signature\x20verification\x20failed\x20for\x20message\x20'+b,'failedCheck':'merkle'};}return{'valid':!![]};}export function verifyEd25519Signature(a,b,c){try{const d=hexToBytes(a['replace']('0x','')),e=hexToBytes(c['replace']('0x','')),f=new TextEncoder()['encode'](b);return verifyEd25519(d,f,e);}catch{return![];}}export function verifyWtsMessages(a){if(a['length']===0x0)return{'valid':!![]};const b=[...a]['sort']((d,e)=>d['leafIndex']-e['leafIndex']);for(let d=0x0;d<b['length'];d++){const e=b[d];if(e['plaintext']!=null){const f=hashPlaintext(e['plaintext']||'',e['clientTimestamp'],e['guardAddress'],e['passportAddress'],e['lastReceivedLeafIndex']);if(f['toLowerCase']()!==e['plaintextHash']['toLowerCase']())return{'valid':![],'error':'Plaintext\x20hash\x20mismatch\x20for\x20message\x20'+e['id']+'\x20at\x20index\x20'+d,'failedMessageIndex':d,'failedCheck':'plaintext'};}if(e['merkleProof']){const g=calculateMerkleLeafHash(e['plaintextHash'],e['timestamp']),h=verifyMerkleProof(g,{'root':e['merkleRoot'],'siblings':e['merkleProof']['siblings'],'indices':e['merkleProof']['indices']});if(!h)return{'valid':![],'error':'Merkle\x20proof\x20verification\x20failed\x20for\x20message\x20'+e['id']+'\x20at\x20index\x20'+d,'failedMessageIndex':d,'failedCheck':'merkle'};}if(e['serverSignature']&&e['serverPublicKey']){if(!e['merkleRoot'])return{'valid':![],'error':'Missing\x20merkleRoot\x20for\x20message\x20'+e['id']+'\x20at\x20index\x20'+d,'failedMessageIndex':d,'failedCheck':'merkle'};if(!e['timestamp'])return{'valid':![],'error':'Missing\x20timestamp\x20for\x20message\x20'+e['id']+'\x20at\x20index\x20'+d,'failedMessageIndex':d,'failedCheck':'merkle'};if(!e['prevRoot'])return{'valid':![],'error':'Missing\x20prevRoot\x20for\x20message\x20'+e['id']+'\x20at\x20index\x20'+d,'failedMessageIndex':d,'failedCheck':'merkle'};const j=e['prevRoot']+':'+e['merkleRoot']+':'+e['timestamp']+':'+e['serverPublicKey'],k=verifyEd25519Signature(e['serverPublicKey'],j,e['serverSignature']);if(!k)return{'valid':![],'error':'Server\x20signature\x20verification\x20failed\x20for\x20message\x20'+e['id']+'\x20at\x20index\x20'+d,'failedMessageIndex':d,'failedCheck':'merkle'};}}const c=verifyMerkleChain(b['map'](l=>({'leafIndex':l['leafIndex'],'prevRoot':l['merkleRoot'],'newRoot':l['merkleRoot'],'plaintextHash':l['plaintextHash'],'serverTimestamp':l['timestamp']})));if(!c['valid'])return{'valid':![],'error':c['error'],'failedCheck':'chain'};return{'valid':!![]};}

package/dist/esm/w/messenger/index.d.ts

@@ -1,21 +1,3 @@
-/**
- * Wowok Messenger SDK
- *
- * 基于三重信任模型的端到端加密消息系统：
- *
- * 1. 身份信任（Identity Trust）
- *    - 基于 wowok 账户体系的 Ed25519 签名
- *    - 每个用户的钱包地址即身份标识
- *
- * 2. 加密信任（Encryption Trust）
- *    - 基于 Signal Protocol 的双棘轮算法
- *    - 端到端加密，服务器无法解密
- *
- * 3. 时序信任（Temporal Trust）
- *    - 基于 Merkle Tree 的消息时序完整性
- *    - 服务器签名确保消息顺序
- *    - 链上证明提供不可篡改的时间戳
- */
 export { MessengerManager } from "./messenger-manager.js";
 export { Messenger } from "./messenger.js";
 export * from "./messenger-api.js";

package/dist/esm/w/messenger/index.js

@@ -1,28 +1 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Wowok Messenger SDK
- *
- * 基于三重信任模型的端到端加密消息系统：
- *
- * 1. 身份信任（Identity Trust）
- *    - 基于 wowok 账户体系的 Ed25519 签名
- *    - 每个用户的钱包地址即身份标识
- *
- * 2. 加密信任（Encryption Trust）
- *    - 基于 Signal Protocol 的双棘轮算法
- *    - 端到端加密，服务器无法解密
- *
- * 3. 时序信任（Temporal Trust）
- *    - 基于 Merkle Tree 的消息时序完整性
- *    - 服务器签名确保消息顺序
- *    - 链上证明提供不可篡改的时间戳
- */
-// ========== 主类 ==========
-export { MessengerManager } from "./messenger-manager.js";
-export { Messenger } from "./messenger.js";
-// ========== Messenger API ==========
-export * from "./messenger-api.js";
-// ========== 枚举和常量 ==========
-export { MessageType, MessageDirection, MessageStatus, MessengerErrorCode, DEFAULT_MESSENGER_CONFIG, MessengerError, DEFAULT_QUERY_LIMIT, MAX_QUERY_LIMIT, } from "./types.js";
-//# sourceMappingURL=index.js.map
+export{MessengerManager}from'./messenger-manager.js';export{Messenger}from'./messenger.js';export*from'./messenger-api.js';export{MessageType,MessageDirection,MessageStatus,MessengerErrorCode,DEFAULT_MESSENGER_CONFIG,MessengerError,DEFAULT_QUERY_LIMIT,MAX_QUERY_LIMIT}from'./types.js';