zapo-js 0.1.1 → 0.2.0

package/dist/message/incoming.js

@@ -6,33 +6,13 @@ const padding_1 = require("./padding");
 const _proto_1 = require("../proto.js");
 const constants_1 = require("../protocol/constants");
 const jid_1 = require("../protocol/jid");
-const message_1 = require("../transport/node/builders/message");
+const global_1 = require("../transport/node/builders/global");
 const helpers_1 = require("../transport/node/helpers");
 const primitives_1 = require("../util/primitives");
-function pickMessageSenderJid(node) {
-    return node.attrs.participant ?? node.attrs.from;
-}
-function pickMessageChatJid(node) {
-    return node.attrs.from;
-}
-function parseMessageTimestamp(value) {
-    if (!value) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isSafeInteger(parsed)) {
-        return undefined;
-    }
-    return parsed;
-}
 function pickNextRetryCount(node) {
     const retryNode = (0, helpers_1.findNodeChild)(node, 'retry');
-    const countRaw = retryNode?.attrs.count;
-    if (!countRaw) {
-        return 1;
-    }
-    const parsed = Number.parseInt(countRaw, 10);
-    if (!Number.isSafeInteger(parsed) || parsed < 1) {
+    const parsed = (0, primitives_1.parseOptionalInt)(retryNode?.attrs.count);
+    if (!parsed || parsed < 1) {
         return 1;
     }
     return parsed + 1;
@@ -42,21 +22,26 @@ function buildIncomingEventRawNode(node) {
     if (!Array.isArray(nodeContent) || nodeContent.length === 0) {
         return node;
     }
-    let redacted = false;
-    const children = nodeContent.map((child) => {
-        if (child.tag !== constants_1.WA_MESSAGE_TAGS.ENC) {
-            return child;
+    let children = null;
+    for (let index = 0; index < nodeContent.length; index += 1) {
+        const child = nodeContent[index];
+        const shouldRedact = child.tag === constants_1.WA_MESSAGE_TAGS.ENC &&
+            (typeof child.content === 'string' || child.content instanceof Uint8Array);
+        if (!shouldRedact) {
+            if (children) {
+                children.push(child);
+            }
+            continue;
         }
-        if (typeof child.content === 'string' || child.content instanceof Uint8Array) {
-            redacted = true;
-            return {
-                tag: child.tag,
-                attrs: child.attrs
-            };
+        if (!children) {
+            children = nodeContent.slice(0, index);
         }
-        return child;
-    });
-    if (!redacted) {
+        children.push({
+            tag: child.tag,
+            attrs: child.attrs
+        });
+    }
+    if (!children) {
         return node;
     }
     // Strip heavy encrypted payload from event snapshots to reduce retention.
@@ -108,46 +93,21 @@ function shouldEmitIncomingMessage(message) {
     if (!pickDirectSenderKeyDistributionPayload(message)) {
         return true;
     }
-    for (const [field, value] of Object.entries(message)) {
-        if (value === null || value === undefined) {
-            continue;
-        }
+    const messageRecord = message;
+    for (const field in messageRecord) {
         if (field === 'senderKeyDistributionMessage' ||
             field === 'fastRatchetKeySenderKeyDistributionMessage' ||
             field === '$$unknownFieldCount') {
             continue;
         }
+        const value = messageRecord[field];
+        if (value === null || value === undefined) {
+            continue;
+        }
         return true;
     }
     return false;
 }
-async function maybeProcessSenderKeyDistributionMessage(senderJid, message, options, node) {
-    if (!senderJid || !options.senderKeyManager) {
-        return;
-    }
-    const senderKeyDistribution = pickSenderKeyDistributionPayload(message);
-    if (!senderKeyDistribution) {
-        return;
-    }
-    try {
-        await options.senderKeyManager.processSenderKeyDistributionPayload(senderKeyDistribution.groupId, (0, jid_1.parseSignalAddressFromJid)(senderJid), senderKeyDistribution.payload);
-        options.logger.debug('processed incoming sender key distribution', {
-            id: node.attrs.id,
-            from: node.attrs.from,
-            participant: node.attrs.participant,
-            groupId: senderKeyDistribution.groupId
-        });
-    }
-    catch (error) {
-        options.logger.warn('failed to process incoming sender key distribution', {
-            id: node.attrs.id,
-            from: node.attrs.from,
-            participant: node.attrs.participant,
-            groupId: senderKeyDistribution.groupId,
-            message: (0, primitives_1.toError)(error).message
-        });
-    }
-}
 async function sendRetryReceiptForDecryptFailure(node, options, error, encType) {
     const stanzaId = node.attrs.id;
     const from = node.attrs.from;
@@ -165,7 +125,13 @@ async function sendRetryReceiptForDecryptFailure(node, options, error, encType)
     if (options.onDecryptFailure) {
         return options.onDecryptFailure(retryContext, error);
     }
-    const retryReceiptNode = (0, message_1.buildInboundRetryReceiptNode)(node, stanzaId, from, options.getMeJid?.(), pickNextRetryCount(node));
+    const retryReceiptNode = (0, global_1.buildReceiptNode)({
+        kind: 'retry',
+        node,
+        id: stanzaId,
+        to: from,
+        retryCount: pickNextRetryCount(node)
+    });
     try {
         await options.sendNode(retryReceiptNode);
         options.logger.debug('sent retry receipt for undecryptable incoming message', {
@@ -189,15 +155,37 @@ async function sendRetryReceiptForDecryptFailure(node, options, error, encType)
 }
 async function decryptAndProcessEncNode(node, encNode, encType, senderJid, options, decrypt) {
     try {
-        const decryptedPayload = await decrypt((0, helpers_1.decodeNodeContentBase64OrBytes)(encNode.content, 'message.enc'));
+        const senderAddress = (0, jid_1.parseSignalAddressFromJid)(senderJid);
+        const decryptedPayload = await decrypt((0, helpers_1.decodeNodeContentBase64OrBytes)(encNode.content, 'message.enc'), senderAddress);
         const unpaddedPlaintext = (0, padding_1.unpadPkcs7)(decryptedPayload);
-        const message = normalizeIncomingDecryptedMessage(_proto_1.proto.Message.decode(unpaddedPlaintext));
-        await maybeProcessSenderKeyDistributionMessage(senderJid, message, options, node);
+        const decodedMessage = _proto_1.proto.Message.decode(unpaddedPlaintext);
+        const message = (0, device_sent_1.unwrapDeviceSentMessage)(decodedMessage) ?? decodedMessage;
+        const senderKeyDistribution = pickSenderKeyDistributionPayload(message);
+        if (senderKeyDistribution && options.senderKeyManager) {
+            try {
+                await options.senderKeyManager.processSenderKeyDistributionPayload(senderKeyDistribution.groupId, senderAddress, senderKeyDistribution.payload);
+                options.logger.debug('processed incoming sender key distribution', {
+                    id: node.attrs.id,
+                    from: node.attrs.from,
+                    participant: node.attrs.participant,
+                    groupId: senderKeyDistribution.groupId
+                });
+            }
+            catch (error) {
+                options.logger.warn('failed to process incoming sender key distribution', {
+                    id: node.attrs.id,
+                    from: node.attrs.from,
+                    participant: node.attrs.participant,
+                    groupId: senderKeyDistribution.groupId,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        }
         if (shouldEmitIncomingMessage(message)) {
-            const chatJid = pickMessageChatJid(node);
+            const chatJid = node.attrs.from;
             options.emitIncomingMessage?.({
                 ...buildBaseIncomingEvent(node),
-                timestampSeconds: parseMessageTimestamp(node.attrs.t),
+                timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
                 senderJid,
                 encryptionType: encType,
                 isGroupChat: chatJid ? (0, jid_1.isGroupJid)(chatJid) : false,
@@ -228,57 +216,68 @@ async function handleIncomingMessageAck(node, options) {
         return false;
     }
     let shouldSendStandardReceipt = true;
-    const encNodes = (0, helpers_1.getNodeChildrenByTag)(node, constants_1.WA_MESSAGE_TAGS.ENC);
-    if (encNodes.length > 1 && encNodes[0]?.attrs.type === 'skmsg') {
-        options.logger.warn('incoming message enc order is unexpected: skmsg first', {
-            id: node.attrs.id,
-            from: node.attrs.from,
-            participant: node.attrs.participant,
-            encCount: encNodes.length
-        });
-    }
-    if (encNodes.length > 0) {
-        const senderJid = pickMessageSenderJid(node);
-        const chatJid = pickMessageChatJid(node);
+    const nodeContent = node.content;
+    if (Array.isArray(nodeContent) && nodeContent.length > 0) {
+        const senderJid = node.attrs.participant ?? node.attrs.from;
         let hasSuccessfulDecrypt = false;
         let firstDecryptFailure = null;
-        for (const encNode of encNodes) {
-            const encType = encNode.attrs.type;
-            if (!encType) {
+        let encCount = 0;
+        let firstEncType;
+        for (const child of nodeContent) {
+            if (child.tag !== constants_1.WA_MESSAGE_TAGS.ENC) {
                 continue;
             }
-            if (encType === 'skmsg') {
-                if (!senderJid || !chatJid || !options.senderKeyManager) {
-                    options.emitUnhandledStanza?.({
-                        ...buildBaseIncomingEvent(node),
-                        reason: 'message.skmsg.missing_group_context'
-                    });
-                    continue;
-                }
-                const result = await decryptAndProcessEncNode(node, encNode, encType, senderJid, options, (ciphertext) => options.senderKeyManager.decryptGroupMessage({
-                    groupId: chatJid,
-                    sender: (0, jid_1.parseSignalAddressFromJid)(senderJid),
-                    ciphertext
-                }));
-                if (result.success) {
-                    hasSuccessfulDecrypt = true;
-                }
-                else if (!firstDecryptFailure) {
-                    firstDecryptFailure = result;
-                }
-                continue;
+            encCount += 1;
+            if (firstEncType === undefined) {
+                firstEncType = child.attrs.type;
             }
-            if ((encType === 'msg' || encType === 'pkmsg') && senderJid && options.signalProtocol) {
-                const result = await decryptAndProcessEncNode(node, encNode, encType, senderJid, options, (ciphertext) => options.signalProtocol.decryptMessage((0, jid_1.parseSignalAddressFromJid)(senderJid), { type: encType, ciphertext }));
-                if (result.success) {
-                    hasSuccessfulDecrypt = true;
+            let result = null;
+            switch (child.attrs.type) {
+                case 'skmsg': {
+                    if (!senderJid || !node.attrs.from || !options.senderKeyManager) {
+                        options.emitUnhandledStanza?.({
+                            ...buildBaseIncomingEvent(node),
+                            reason: 'message.skmsg.missing_group_context'
+                        });
+                        continue;
+                    }
+                    const groupId = node.attrs.from;
+                    result = await decryptAndProcessEncNode(node, child, 'skmsg', senderJid, options, (ciphertext, senderAddress) => options.senderKeyManager.decryptGroupMessage({
+                        groupId,
+                        sender: senderAddress,
+                        ciphertext
+                    }));
+                    break;
                 }
-                else if (!firstDecryptFailure) {
-                    firstDecryptFailure = result;
+                case 'msg':
+                case 'pkmsg': {
+                    if (!senderJid || !options.signalProtocol) {
+                        continue;
+                    }
+                    const encType = child.attrs.type === 'msg' ? 'msg' : 'pkmsg';
+                    result = await decryptAndProcessEncNode(node, child, encType, senderJid, options, (ciphertext, senderAddress) => options.signalProtocol.decryptMessage(senderAddress, {
+                        type: encType,
+                        ciphertext
+                    }));
+                    break;
                 }
+                default:
+                    continue;
             }
+            if (result.success)
+                hasSuccessfulDecrypt = true;
+            else if (!firstDecryptFailure)
+                firstDecryptFailure = result;
         }
-        if (!hasSuccessfulDecrypt && firstDecryptFailure) {
+        if (encCount > 1 && firstEncType === 'skmsg') {
+            options.logger.warn('incoming message enc order is unexpected: skmsg first', {
+                id: node.attrs.id,
+                from: node.attrs.from,
+                participant: node.attrs.participant,
+                encCount
+            });
+        }
+        if (encCount > 0 && !hasSuccessfulDecrypt && firstDecryptFailure) {
             shouldSendStandardReceipt = !(await sendRetryReceiptForDecryptFailure(node, options, firstDecryptFailure.error, firstDecryptFailure.encType));
         }
     }
@@ -293,7 +292,13 @@ async function handleIncomingMessageAck(node, options) {
         return true;
     }
     if (node.attrs.type === constants_1.WA_MESSAGE_TYPES.MEDIA_NOTIFY) {
-        const ackNode = (0, message_1.buildInboundMessageAckNode)(node, id, from, options.getMeJid?.());
+        const ackNode = (0, global_1.buildAckNode)({
+            kind: 'message',
+            node,
+            id,
+            to: from,
+            from: options.getMeJid?.()
+        });
         options.logger.debug('sending inbound message ack', {
             id,
             to: from,
@@ -306,7 +311,12 @@ async function handleIncomingMessageAck(node, options) {
     if (!shouldSendStandardReceipt) {
         return true;
     }
-    const receiptNode = (0, message_1.buildInboundDeliveryReceiptNode)(node, id, from);
+    const receiptNode = (0, global_1.buildReceiptNode)({
+        kind: 'delivery',
+        node,
+        id,
+        to: from
+    });
     options.logger.debug('sending inbound message receipt', {
         id,
         to: from,
@@ -316,6 +326,3 @@ async function handleIncomingMessageAck(node, options) {
     await options.sendNode(receiptNode);
     return true;
 }
-function normalizeIncomingDecryptedMessage(message) {
-    return (0, device_sent_1.unwrapDeviceSentMessage)(message) ?? message;
-}

package/dist/message/index.js

@@ -17,4 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageClient = void 0;
 var WaMessageClient_1 = require("./WaMessageClient");
 Object.defineProperty(exports, "WaMessageClient", { enumerable: true, get: function () { return WaMessageClient_1.WaMessageClient; } });
+__exportStar(require("./addon-crypto"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./use-case-secret"), exports);

package/dist/message/phash.js

@@ -8,7 +8,9 @@ async function computePhashV2(participants) {
     if (participants.length === 0) {
         return '2:';
     }
-    const canonical = participants.map((participant) => toPhashCanonicalWid(participant));
+    const canonical = new Array(participants.length);
+    for (let i = 0; i < participants.length; i += 1)
+        canonical[i] = toPhashCanonicalWid(participants[i]);
     const joined = canonical.sort().join('');
     const digest = await (0, core_1.sha256)(bytes_1.TEXT_ENCODER.encode(joined));
     return `2:${(0, bytes_1.bytesToBase64)(digest.subarray(0, 6))}`;