zapo-js 0.1.2 → 0.3.0

package/dist/message/addon-crypto.js

@@ -4,8 +4,14 @@ exports.shouldUseAddonAdditionalData = shouldUseAddonAdditionalData;
 exports.buildAddonAdditionalData = buildAddonAdditionalData;
 exports.encryptAddonPayload = encryptAddonPayload;
 exports.decryptAddonPayload = decryptAddonPayload;
+exports.identifyEncryptedAddon = identifyEncryptedAddon;
+exports.decodeAddonPlaintext = decodeAddonPlaintext;
+exports.resolveParentMessageSecret = resolveParentMessageSecret;
+exports.resolvePollOptionNames = resolvePollOptionNames;
 const _crypto_1 = require("../crypto/index.js");
+const content_1 = require("./content");
 const use_case_secret_1 = require("./use-case-secret");
+const _proto_1 = require("../proto.js");
 const bytes_1 = require("../util/bytes");
 const WA_ADDON_ENCRYPTION_NONCE_BYTES = 12;
 function shouldUseAddonAdditionalData(modificationType) {
@@ -47,6 +53,131 @@ async function decryptAddonPayload(input) {
     const additionalData = resolveAddonAdditionalData(input);
     return (0, _crypto_1.aesGcmDecrypt)(key, iv, (0, bytes_1.toBytesView)(input.ciphertext), additionalData);
 }
+function identifyEncryptedAddon(message) {
+    const msg = (0, content_1.unwrapMessage)(message);
+    if (msg.encReactionMessage) {
+        const { targetMessageKey, encPayload, encIv } = msg.encReactionMessage;
+        if (targetMessageKey && encPayload && encIv) {
+            return {
+                kind: 'reaction',
+                targetMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.ENC_REACTION,
+                raw: message
+            };
+        }
+    }
+    if (msg.pollUpdateMessage) {
+        const { pollCreationMessageKey, vote } = msg.pollUpdateMessage;
+        if (pollCreationMessageKey && vote?.encPayload && vote.encIv) {
+            return {
+                kind: 'poll_vote',
+                targetMessageKey: pollCreationMessageKey,
+                encPayload: vote.encPayload,
+                encIv: vote.encIv,
+                modificationType: use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE,
+                raw: message
+            };
+        }
+    }
+    if (msg.encEventResponseMessage) {
+        const { eventCreationMessageKey, encPayload, encIv } = msg.encEventResponseMessage;
+        if (eventCreationMessageKey && encPayload && encIv) {
+            return {
+                kind: 'event_response',
+                targetMessageKey: eventCreationMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE,
+                raw: message
+            };
+        }
+    }
+    if (msg.encCommentMessage) {
+        const { targetMessageKey, encPayload, encIv } = msg.encCommentMessage;
+        if (targetMessageKey && encPayload && encIv) {
+            return {
+                kind: 'comment',
+                targetMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.ENC_COMMENT,
+                raw: message
+            };
+        }
+    }
+    return null;
+}
+function decodeAddonPlaintext(kind, plaintext) {
+    switch (kind) {
+        case 'reaction':
+            return { kind, reaction: _proto_1.proto.Message.ReactionMessage.decode(plaintext) };
+        case 'poll_vote':
+            return {
+                kind,
+                pollVote: _proto_1.proto.Message.PollVoteMessage.decode(plaintext),
+                selectedOptionNames: null
+            };
+        case 'event_response':
+            return { kind, eventResponse: _proto_1.proto.Message.EventResponseMessage.decode(plaintext) };
+        case 'comment':
+            return { kind, comment: _proto_1.proto.Message.CommentMessage.decode(plaintext) };
+    }
+}
+async function resolveParentMessageSecret(targetMessageId, messageSecretStore, messageStore) {
+    const cached = await messageSecretStore.get(targetMessageId);
+    if (cached)
+        return cached;
+    const record = await messageStore.getById(targetMessageId);
+    if (!record?.messageBytes)
+        return null;
+    try {
+        const decoded = _proto_1.proto.Message.decode(record.messageBytes);
+        const secret = decoded.messageContextInfo?.messageSecret;
+        if (!secret || secret.byteLength !== use_case_secret_1.WA_MESSAGE_SECRET_BYTES)
+            return null;
+        return { secret, senderJid: record.senderJid ?? '' };
+    }
+    catch {
+        return null;
+    }
+}
+async function resolvePollOptionNames(selectedOptions, pollCreationMessageId, messageStore) {
+    const record = await messageStore.getById(pollCreationMessageId);
+    if (!record?.messageBytes)
+        return null;
+    let decoded;
+    try {
+        decoded = _proto_1.proto.Message.decode(record.messageBytes);
+    }
+    catch {
+        return null;
+    }
+    const pollMsg = (0, content_1.unwrapMessage)(decoded);
+    const options = pollMsg.pollCreationMessage?.options ??
+        pollMsg.pollCreationMessageV2?.options ??
+        pollMsg.pollCreationMessageV3?.options ??
+        pollMsg.pollCreationMessageV5?.options;
+    if (!options || options.length === 0)
+        return null;
+    const hashToName = new Map();
+    for (const option of options) {
+        if (!option.optionName)
+            continue;
+        const hash = await (0, _crypto_1.sha256)(bytes_1.TEXT_ENCODER.encode(option.optionName));
+        hashToName.set((0, bytes_1.bytesToHex)(hash), option.optionName);
+    }
+    const names = [];
+    for (const selected of selectedOptions) {
+        const hex = (0, bytes_1.bytesToHex)(selected);
+        const name = hashToName.get(hex);
+        if (!name)
+            return null;
+        names.push(name);
+    }
+    return names;
+}
 function assertAddonIv(iv) {
     const normalized = (0, bytes_1.toBytesView)(iv);
     if (normalized.byteLength !== WA_ADDON_ENCRYPTION_NONCE_BYTES) {

package/dist/message/content.js

@@ -1,24 +1,221 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSendMediaMessage = isSendMediaMessage;
+exports.unwrapMessage = unwrapMessage;
 exports.resolveMessageTypeAttr = resolveMessageTypeAttr;
+exports.needsSecretPersistence = needsSecretPersistence;
+exports.resolveEditAttr = resolveEditAttr;
+exports.resolveEncMediaType = resolveEncMediaType;
+exports.resolveMetaAttrs = resolveMetaAttrs;
+const _proto_1 = require("../proto.js");
+const constants_1 = require("../protocol/constants");
 function isSendMediaMessage(content) {
-    return (!!content &&
-        typeof content === 'object' &&
-        'type' in content &&
-        'media' in content &&
-        'mimetype' in content);
+    return !!content && typeof content === 'object' && 'type' in content && 'media' in content;
+}
+function unwrapMessage(message) {
+    let msg = message;
+    for (;;) {
+        const inner = msg.ephemeralMessage?.message ??
+            msg.groupMentionedMessage?.message ??
+            msg.botInvokeMessage?.message ??
+            msg.deviceSentMessage?.message ??
+            msg.viewOnceMessage?.message ??
+            msg.viewOnceMessageV2?.message ??
+            msg.documentWithCaptionMessage?.message;
+        if (!inner)
+            return msg;
+        msg = inner;
+    }
 }
 function resolveMessageTypeAttr(message) {
-    if (message.reactionMessage) {
-        return 'reaction';
+    const msg = unwrapMessage(message);
+    if (msg.reactionMessage || msg.encReactionMessage) {
+        return constants_1.WA_STANZA_MSG_TYPES.REACTION;
+    }
+    if (msg.eventMessage ||
+        msg.encEventResponseMessage ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
+        return constants_1.WA_STANZA_MSG_TYPES.EVENT;
+    }
+    if (msg.pollCreationMessage ||
+        msg.pollCreationMessageV2 ||
+        msg.pollCreationMessageV3 ||
+        msg.pollCreationMessageV5 ||
+        msg.pollUpdateMessage ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION) {
+        return constants_1.WA_STANZA_MSG_TYPES.POLL;
+    }
+    if (msg.extendedTextMessage?.matchedText && msg.extendedTextMessage.matchedText.trim() !== '') {
+        return constants_1.WA_STANZA_MSG_TYPES.MEDIA;
+    }
+    if ((msg.conversation !== undefined && msg.conversation !== null) ||
+        (msg.extendedTextMessage && !msg.extendedTextMessage.matchedText) ||
+        msg.protocolMessage ||
+        msg.interactiveMessage ||
+        msg.keepInChatMessage ||
+        msg.requestPhoneNumberMessage ||
+        msg.editedMessage ||
+        msg.pinInChatMessage ||
+        msg.encCommentMessage ||
+        msg.newsletterAdminInviteMessage ||
+        msg.pollResultSnapshotMessage ||
+        msg.pollResultSnapshotMessageV3 ||
+        msg.templateButtonReplyMessage ||
+        msg.messageHistoryNotice ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_SCHEDULE) {
+        return constants_1.WA_STANZA_MSG_TYPES.TEXT;
+    }
+    return constants_1.WA_STANZA_MSG_TYPES.MEDIA;
+}
+const REVOKED_REACTION_TEXT = '';
+function needsSecretPersistence(message) {
+    const msg = unwrapMessage(message);
+    return !!(msg.pollCreationMessage ||
+        msg.pollCreationMessageV2 ||
+        msg.pollCreationMessageV3 ||
+        msg.pollCreationMessageV4 ||
+        msg.pollCreationMessageV5 ||
+        msg.pollCreationMessageV6 ||
+        msg.eventMessage);
+}
+function resolveEditAttr(message, subtype) {
+    const msg = unwrapMessage(message);
+    if (msg.protocolMessage) {
+        const protocolType = msg.protocolMessage.type;
+        if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.REVOKE) {
+            return subtype === 'admin_revoke'
+                ? constants_1.WA_EDIT_ATTRS.ADMIN_REVOKE
+                : constants_1.WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT) {
+            return constants_1.WA_EDIT_ATTRS.MESSAGE_EDIT;
+        }
+        return null;
+    }
+    if (msg.secretEncryptedMessage) {
+        const encType = msg.secretEncryptedMessage.secretEncType;
+        if (encType === _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT ||
+            encType === _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT) {
+            return constants_1.WA_EDIT_ATTRS.MESSAGE_EDIT;
+        }
+    }
+    if (msg.editedMessage) {
+        return constants_1.WA_EDIT_ATTRS.MESSAGE_EDIT;
+    }
+    if (msg.reactionMessage) {
+        if (msg.reactionMessage.text === REVOKED_REACTION_TEXT) {
+            return constants_1.WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        return null;
+    }
+    if (msg.keepInChatMessage) {
+        if (msg.keepInChatMessage.key?.fromMe === true &&
+            msg.keepInChatMessage.keepType === _proto_1.proto.KeepType.UNDO_KEEP_FOR_ALL) {
+            return constants_1.WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        return null;
+    }
+    if (msg.pinInChatMessage) {
+        return constants_1.WA_EDIT_ATTRS.PIN_IN_CHAT;
+    }
+    return null;
+}
+function resolveEncMediaType(message) {
+    const msg = unwrapMessage(message);
+    if (msg.imageMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.IMAGE;
+    if (msg.stickerMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.STICKER;
+    if (msg.locationMessage) {
+        return msg.locationMessage.isLive
+            ? constants_1.WA_ENC_MEDIA_TYPES.LIVE_LOCATION
+            : constants_1.WA_ENC_MEDIA_TYPES.LOCATION;
+    }
+    if (msg.contactMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.VCARD;
+    if (msg.contactsArrayMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.CONTACT_ARRAY;
+    if (msg.documentMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.DOCUMENT;
+    if (msg.audioMessage) {
+        return msg.audioMessage.ptt ? constants_1.WA_ENC_MEDIA_TYPES.PTT : constants_1.WA_ENC_MEDIA_TYPES.AUDIO;
+    }
+    if (msg.videoMessage) {
+        return msg.videoMessage.gifPlayback ? constants_1.WA_ENC_MEDIA_TYPES.GIF : constants_1.WA_ENC_MEDIA_TYPES.VIDEO;
+    }
+    if (msg.ptvMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.PTV;
+    if (msg.buttonsMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.BUTTON;
+    if (msg.buttonsResponseMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.BUTTON_RESPONSE;
+    if (msg.listMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.LIST;
+    if (msg.listResponseMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.LIST_RESPONSE;
+    if (msg.orderMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.ORDER;
+    if (msg.productMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.PRODUCT;
+    if (msg.groupInviteMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.URL;
+    if (msg.interactiveResponseMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.NATIVE_FLOW_RESPONSE;
+    if (msg.messageHistoryBundle)
+        return constants_1.WA_ENC_MEDIA_TYPES.GROUP_HISTORY;
+    if (msg.extendedTextMessage?.matchedText && msg.extendedTextMessage.matchedText.trim() !== '') {
+        return constants_1.WA_ENC_MEDIA_TYPES.URL;
+    }
+    return null;
+}
+function resolveMetaAttrs(message) {
+    const msg = unwrapMessage(message);
+    let polltype;
+    let eventType;
+    let viewOnce;
+    if (msg.pollCreationMessage || msg.pollCreationMessageV2 || msg.pollCreationMessageV3) {
+        polltype = constants_1.WA_POLL_META_TYPES.CREATION;
+    }
+    else if (msg.pollUpdateMessage) {
+        polltype = constants_1.WA_POLL_META_TYPES.VOTE;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT) {
+        polltype = constants_1.WA_POLL_META_TYPES.EDIT;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION) {
+        polltype = constants_1.WA_POLL_META_TYPES.EDIT;
+    }
+    if (msg.eventMessage) {
+        eventType = constants_1.WA_EVENT_META_TYPES.CREATION;
+    }
+    else if (msg.encEventResponseMessage) {
+        eventType = constants_1.WA_EVENT_META_TYPES.RESPONSE;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
+        eventType = constants_1.WA_EVENT_META_TYPES.EDIT;
+    }
+    if (message.viewOnceMessage || message.viewOnceMessageV2) {
+        viewOnce = 'true';
     }
-    if (message.imageMessage ||
-        message.videoMessage ||
-        message.audioMessage ||
-        message.documentMessage ||
-        message.stickerMessage) {
-        return 'media';
+    if (!polltype && !eventType && !viewOnce) {
+        return null;
     }
-    return 'text';
+    const attrs = {};
+    if (polltype)
+        attrs.polltype = polltype;
+    if (eventType)
+        attrs.event_type = eventType;
+    if (viewOnce)
+        attrs.view_once = viewOnce;
+    return attrs;
 }

package/dist/message/icdc.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDeviceKeyHash = computeDeviceKeyHash;
+exports.resolveIcdcMeta = resolveIcdcMeta;
+exports.injectDeviceListMetadata = injectDeviceListMetadata;
+const _crypto_1 = require("../crypto/index.js");
+const jid_1 = require("../protocol/jid");
+const bytes_1 = require("../util/bytes");
+const ICDC_DEFAULT_HASH_LENGTH = 8;
+const ICDC_FRESHNESS_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
+const DEVICE_LIST_METADATA_VERSION = 2;
+async function computeDeviceKeyHash(identityKeys, hashLength) {
+    const length = hashLength ?? ICDC_DEFAULT_HASH_LENGTH;
+    if (identityKeys.length === 0) {
+        return new Uint8Array(length);
+    }
+    const rawKeys = new Array(identityKeys.length);
+    for (let i = 0; i < identityKeys.length; i += 1) {
+        rawKeys[i] =
+            identityKeys[i].byteLength === 33 ? (0, _crypto_1.toRawPubKey)(identityKeys[i]) : identityKeys[i];
+    }
+    const combined = (0, bytes_1.concatBytes)(rawKeys);
+    const hash = await (0, _crypto_1.sha256)(combined);
+    return hash.subarray(0, length);
+}
+async function resolveIcdcMeta(deviceJids, identityStore, updatedAtMs, localIdentity, hashLength) {
+    if (deviceJids.length === 0) {
+        return null;
+    }
+    const addresses = new Array(deviceJids.length);
+    for (let i = 0; i < deviceJids.length; i += 1) {
+        addresses[i] = (0, jid_1.parseSignalAddressFromJid)(deviceJids[i]);
+    }
+    const remoteKeys = await identityStore.getRemoteIdentities(addresses);
+    const keys = [];
+    for (let i = 0; i < addresses.length; i += 1) {
+        const key = remoteKeys[i];
+        if (key) {
+            keys.push(key);
+        }
+        else if (localIdentity &&
+            addresses[i].user === localIdentity.address.user &&
+            addresses[i].device === localIdentity.address.device) {
+            keys.push(localIdentity.pubKey);
+        }
+    }
+    if (keys.length === 0) {
+        return null;
+    }
+    const keyHash = await computeDeviceKeyHash(keys, hashLength);
+    const timestamp = updatedAtMs !== undefined && Date.now() - updatedAtMs < ICDC_FRESHNESS_THRESHOLD_MS
+        ? Math.floor(updatedAtMs / 1000)
+        : undefined;
+    return { keyHash, timestamp };
+}
+function injectDeviceListMetadata(message, senderIcdc, recipientIcdc) {
+    if (!senderIcdc && !recipientIcdc) {
+        return message;
+    }
+    const deviceListMetadata = {};
+    if (senderIcdc) {
+        deviceListMetadata.senderKeyHash = senderIcdc.keyHash;
+        if (senderIcdc.timestamp !== undefined) {
+            deviceListMetadata.senderTimestamp = senderIcdc.timestamp;
+        }
+    }
+    if (recipientIcdc) {
+        deviceListMetadata.recipientKeyHash = recipientIcdc.keyHash;
+        if (recipientIcdc.timestamp !== undefined) {
+            deviceListMetadata.recipientTimestamp = recipientIcdc.timestamp;
+        }
+    }
+    return {
+        ...message,
+        messageContextInfo: {
+            ...message.messageContextInfo,
+            deviceListMetadata,
+            deviceListMetadataVersion: DEVICE_LIST_METADATA_VERSION
+        }
+    };
+}

package/dist/message/incoming.js

@@ -6,12 +6,9 @@ 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 parseMessageTimestamp(value) {
-    return (0, primitives_1.parseOptionalInt)(value);
-}
 function pickNextRetryCount(node) {
     const retryNode = (0, helpers_1.findNodeChild)(node, 'retry');
     const parsed = (0, primitives_1.parseOptionalInt)(retryNode?.attrs.count);
@@ -54,14 +51,6 @@ function buildIncomingEventRawNode(node) {
         content: children
     };
 }
-function buildBaseIncomingEvent(node) {
-    return {
-        rawNode: buildIncomingEventRawNode(node),
-        stanzaId: node.attrs.id,
-        chatJid: node.attrs.from,
-        stanzaType: node.attrs.type
-    };
-}
 function pickSenderKeyDistributionPayload(message) {
     const direct = pickDirectSenderKeyDistributionPayload(message);
     if (direct) {
@@ -128,7 +117,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', {
@@ -155,7 +150,8 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
         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));
+        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 {
@@ -180,8 +176,11 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
         if (shouldEmitIncomingMessage(message)) {
             const chatJid = node.attrs.from;
             options.emitIncomingMessage?.({
-                ...buildBaseIncomingEvent(node),
-                timestampSeconds: parseMessageTimestamp(node.attrs.t),
+                rawNode: buildIncomingEventRawNode(node),
+                stanzaId: node.attrs.id,
+                chatJid,
+                stanzaType: node.attrs.type,
+                timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
                 senderJid,
                 encryptionType: encType,
                 isGroupChat: chatJid ? (0, jid_1.isGroupJid)(chatJid) : false,
@@ -201,7 +200,10 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
             message: (0, primitives_1.toError)(error).message
         });
         options.emitUnhandledStanza?.({
-            ...buildBaseIncomingEvent(node),
+            rawNode: buildIncomingEventRawNode(node),
+            stanzaId: node.attrs.id,
+            chatJid: node.attrs.from,
+            stanzaType: node.attrs.type,
             reason: `message.decrypt_failed.${encType}`
         });
         return { success: false, encType, error };
@@ -232,7 +234,10 @@ async function handleIncomingMessageAck(node, options) {
                 case 'skmsg': {
                     if (!senderJid || !node.attrs.from || !options.senderKeyManager) {
                         options.emitUnhandledStanza?.({
-                            ...buildBaseIncomingEvent(node),
+                            rawNode: buildIncomingEventRawNode(node),
+                            stanzaId: node.attrs.id,
+                            chatJid: node.attrs.from,
+                            stanzaType: node.attrs.type,
                             reason: 'message.skmsg.missing_group_context'
                         });
                         continue;
@@ -274,7 +279,8 @@ async function handleIncomingMessageAck(node, options) {
             });
         }
         if (encCount > 0 && !hasSuccessfulDecrypt && firstDecryptFailure) {
-            shouldSendStandardReceipt = !(await sendRetryReceiptForDecryptFailure(node, options, firstDecryptFailure.error, firstDecryptFailure.encType));
+            await sendRetryReceiptForDecryptFailure(node, options, firstDecryptFailure.error, firstDecryptFailure.encType);
+            shouldSendStandardReceipt = false;
         }
     }
     const id = node.attrs.id;
@@ -288,7 +294,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,
@@ -301,7 +313,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,
@@ -311,6 +328,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/phash.js

@@ -2,27 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computePhashV2 = computePhashV2;
 const core_1 = require("../crypto/core");
-const jid_1 = require("../protocol/jid");
 const bytes_1 = require("../util/bytes");
 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))}`;
 }
 function toPhashCanonicalWid(jid) {
-    const { user, server } = (0, jid_1.splitJid)(jid);
-    const normalizedServer = server === 'c.us' ? 's.whatsapp.net' : server;
-    const colonIndex = user.indexOf(':');
-    const userWithOptionalAgent = colonIndex >= 0 ? user.slice(0, colonIndex) : user;
-    const baseUser = userWithOptionalAgent.endsWith('.0')
-        ? userWithOptionalAgent.slice(0, userWithOptionalAgent.length - 2)
-        : userWithOptionalAgent;
-    const deviceRaw = colonIndex >= 0 ? user.slice(colonIndex + 1) : '0';
-    const device = Number.parseInt(deviceRaw, 10);
-    const normalizedDevice = Number.isSafeInteger(device) && device >= 0 ? device : 0;
-    return `${baseUser}.0:${normalizedDevice}@${normalizedServer}`;
+    const atIndex = jid.indexOf('@');
+    if (atIndex < 1 || atIndex >= jid.length - 1)
+        return jid;
+    const colonIndex = jid.indexOf(':', 0);
+    const userEnd = colonIndex >= 0 && colonIndex < atIndex ? colonIndex : atIndex;
+    const hasZeroAgent = userEnd >= 2 && jid.charCodeAt(userEnd - 2) === 46 && jid.charCodeAt(userEnd - 1) === 48;
+    const baseUserEnd = hasZeroAgent ? userEnd - 2 : userEnd;
+    const baseUser = jid.slice(0, baseUserEnd);
+    let device = 0;
+    if (colonIndex >= 0 && colonIndex < atIndex) {
+        for (let i = colonIndex + 1; i < atIndex; i += 1) {
+            const digit = jid.charCodeAt(i) - 48;
+            if (digit < 0 || digit > 9) {
+                device = 0;
+                break;
+            }
+            device = device * 10 + digit;
+            if (device > Number.MAX_SAFE_INTEGER) {
+                device = 0;
+                break;
+            }
+        }
+    }
+    const serverStart = atIndex + 1;
+    const serverLen = jid.length - serverStart;
+    const isCUs = serverLen === 4 &&
+        jid.charCodeAt(serverStart) === 99 &&
+        jid.charCodeAt(serverStart + 1) === 46 &&
+        jid.charCodeAt(serverStart + 2) === 117 &&
+        jid.charCodeAt(serverStart + 3) === 115;
+    const normalizedServer = isCUs ? 's.whatsapp.net' : jid.slice(serverStart);
+    return `${baseUser}.0:${device}@${normalizedServer}`;
 }