wowok 2.1.40 → 2.1.41

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

@@ -1,380 +1 @@
-import { ed25519, x25519 } from "@noble/curves/ed25519";
-import { sha256 } from "@noble/hashes/sha256";
-import { randomBytes } from "@noble/hashes/utils";
-function verifyEd25519(publicKey, message, signature) {
-    try {
-        return ed25519.verify(signature, message, publicKey);
-    }
-    catch {
-        return false;
-    }
-}
-export function recoverXed25519FromX25519PrivateKey(x25519PrivateKey) {
-    const x25519PublicKey = x25519.getPublicKey(x25519PrivateKey);
-    const ed25519PrivateKey = x25519PrivateKey;
-    const ed25519PublicKey = ed25519.getPublicKey(ed25519PrivateKey);
-    return {
-        x25519PublicKey,
-        x25519PrivateKey,
-        ed25519PrivateKey,
-        ed25519PublicKey,
-    };
-}
-export function hashSha256(data) {
-    return sha256(data);
-}
-export function hashMessage(data) {
-    const hash = sha256(new TextEncoder().encode(data));
-    return bytesToHex(hash);
-}
-export function hashPlaintext(plaintext, clientTimestamp, guardAddress, passportAddress, lastReceivedLeafIndex) {
-    let data = plaintext;
-    if (lastReceivedLeafIndex !== undefined && lastReceivedLeafIndex >= 0) {
-        data += lastReceivedLeafIndex.toString();
-    }
-    data += clientTimestamp.toString();
-    if (guardAddress) {
-        data += guardAddress;
-    }
-    if (passportAddress) {
-        data += passportAddress;
-    }
-    const hash = sha256(new TextEncoder().encode(data));
-    return "0x" + bytesToHex(hash);
-}
-export function generateNonce() {
-    return bytesToHex(randomBytes(16));
-}
-export function bytesToBase64(bytes) {
-    return Buffer.from(bytes).toString("base64");
-}
-export function base64ToBytes(base64) {
-    return new Uint8Array(Buffer.from(base64, "base64"));
-}
-export function bytesToHex(bytes) {
-    return Buffer.from(bytes).toString("hex");
-}
-export function hexToBytes(hex) {
-    return new Uint8Array(Buffer.from(hex, "hex"));
-}
-export function arrayBufferToUint8Array(buf) {
-    return new Uint8Array(buf);
-}
-export function uint8ArrayToArrayBuffer(arr) {
-    const result = arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
-    return result;
-}
-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;
-}
-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);
-}
-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));
-}
-export function computeNewRoot(prevRoot, leafHash, leafIndex) {
-    const prevRootBytes = new TextEncoder().encode(prevRoot);
-    const leafHashBytes = new TextEncoder().encode(leafHash);
-    const leafIndexBuffer = new ArrayBuffer(4);
-    const leafIndexView = new DataView(leafIndexBuffer);
-    leafIndexView.setUint32(0, leafIndex, true);
-    const leafIndexBytes = new Uint8Array(leafIndexBuffer);
-    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));
-}
-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;
-}
-export function verifyMerkleChain(messages, initialRoot) {
-    if (messages.length === 0) {
-        return { valid: true };
-    }
-    const sortedMessages = [...messages].sort((a, b) => a.leafIndex - b.leafIndex);
-    const zeroRoot = initialRoot || "0x" + "0".repeat(64);
-    let expectedPrevRoot = zeroRoot;
-    for (const msg of sortedMessages) {
-        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,
-            };
-        }
-        const result = verifySingleMerkleRoot(msg.prevRoot, msg.newRoot, msg.plaintextHash, msg.serverTimestamp, msg.leafIndex);
-        if (!result.valid) {
-            return {
-                valid: false,
-                error: `${result.error} at leafIndex ${msg.leafIndex}`,
-                expectedRoot: result.expectedRoot,
-                actualRoot: result.actualRoot,
-            };
-        }
-        expectedPrevRoot = msg.newRoot;
-    }
-    return { valid: true };
-}
-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",
-        };
-    }
-    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 };
-}
-export function verifyMessage(params) {
-    const { messageId, plaintext, plaintextHash, createdAt, guardAddress, passportAddress, lastReceivedLeafIndex, serverSignature, serverPublicKey, merkleMetadata, } = params;
-    const computedPlaintextHash = hashPlaintext(plaintext, createdAt, guardAddress, passportAddress, lastReceivedLeafIndex);
-    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",
-        };
-    }
-    if (merkleMetadata) {
-        if (merkleMetadata.proofSiblings && merkleMetadata.proofIndices) {
-            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",
-                };
-            }
-        }
-        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",
-            };
-        }
-    }
-    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 };
-}
-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;
-    }
-}
-export function verifyWtsMessages(messages) {
-    if (messages.length === 0) {
-        return { valid: true };
-    }
-    const sortedMessages = [...messages].sort((a, b) => a.leafIndex - b.leafIndex);
-    for (let i = 0; i < sortedMessages.length; i++) {
-        const msg = sortedMessages[i];
-        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",
-                };
-            }
-        }
-        if (msg.merkleProof) {
-            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",
-                };
-            }
-        }
-        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",
-                };
-            }
-        }
-    }
-    const chainResult = verifyMerkleChain(sortedMessages.map((msg) => ({
-        leafIndex: msg.leafIndex,
-        prevRoot: msg.merkleRoot,
-        newRoot: msg.merkleRoot,
-        plaintextHash: msg.plaintextHash,
-        serverTimestamp: msg.timestamp,
-    })));
-    if (!chainResult.valid) {
-        return {
-            valid: false,
-            error: chainResult.error,
-            failedCheck: "chain",
-        };
-    }
-    return { valid: true };
-}
+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/cjs/w/messenger/index.js

@@ -1,4 +1 @@
-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";
+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';