zapo-js 0.1.1 → 0.2.0

package/dist/esm/message/addon-crypto.js

@@ -0,0 +1,59 @@
+import { aesGcmDecrypt, aesGcmEncrypt, importAesGcmKey } from '../crypto/index.js';
+import { assertMessageSecret, createUseCaseSecret, WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret.js';
+import { EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../util/bytes.js';
+const WA_ADDON_ENCRYPTION_NONCE_BYTES = 12;
+export function shouldUseAddonAdditionalData(modificationType) {
+    return (modificationType === WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE ||
+        modificationType === WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE);
+}
+export function buildAddonAdditionalData(stanzaId, addOnSenderJid) {
+    if (!stanzaId.trim()) {
+        throw new Error('stanza id must be a non-empty string');
+    }
+    if (!addOnSenderJid.trim()) {
+        throw new Error('addon sender jid must be a non-empty string');
+    }
+    return TEXT_ENCODER.encode(`${stanzaId}\u0000${addOnSenderJid}`);
+}
+export async function encryptAddonPayload(input) {
+    const secret = await createUseCaseSecret({
+        messageSecret: assertMessageSecret(input.messageSecret),
+        stanzaId: input.stanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const key = await importAesGcmKey(secret, ['encrypt']);
+    const iv = assertAddonIv(input.iv);
+    const additionalData = resolveAddonAdditionalData(input);
+    return aesGcmEncrypt(key, iv, toBytesView(input.payload), additionalData);
+}
+export async function decryptAddonPayload(input) {
+    const secret = await createUseCaseSecret({
+        messageSecret: assertMessageSecret(input.messageSecret),
+        stanzaId: input.stanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const key = await importAesGcmKey(secret, ['decrypt']);
+    const iv = assertAddonIv(input.iv);
+    const additionalData = resolveAddonAdditionalData(input);
+    return aesGcmDecrypt(key, iv, toBytesView(input.ciphertext), additionalData);
+}
+function assertAddonIv(iv) {
+    const normalized = toBytesView(iv);
+    if (normalized.byteLength !== WA_ADDON_ENCRYPTION_NONCE_BYTES) {
+        throw new Error(`addon iv must be ${WA_ADDON_ENCRYPTION_NONCE_BYTES} bytes (got ${normalized.byteLength})`);
+    }
+    return normalized;
+}
+function resolveAddonAdditionalData(input) {
+    if (input.additionalData) {
+        return toBytesView(input.additionalData);
+    }
+    if (!shouldUseAddonAdditionalData(input.modificationType)) {
+        return EMPTY_BYTES;
+    }
+    return buildAddonAdditionalData(input.stanzaId, input.modificationSender);
+}

package/dist/esm/message/content.js

@@ -1,3 +1,5 @@
+import { proto } from '../proto.js';
+import { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_POLL_META_TYPES, WA_STANZA_MSG_TYPES } from '../protocol/constants.js';
 export function isSendMediaMessage(content) {
     return (!!content &&
         typeof content === 'object' &&
@@ -5,16 +7,200 @@ export function isSendMediaMessage(content) {
         'media' in content &&
         'mimetype' 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;
+    }
+}
 export function resolveMessageTypeAttr(message) {
-    if (message.reactionMessage) {
-        return 'reaction';
+    const msg = unwrapMessage(message);
+    if (msg.reactionMessage || msg.encReactionMessage) {
+        return WA_STANZA_MSG_TYPES.REACTION;
+    }
+    if (msg.eventMessage ||
+        msg.encEventResponseMessage ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
+        return WA_STANZA_MSG_TYPES.EVENT;
+    }
+    if (msg.pollCreationMessage ||
+        msg.pollCreationMessageV2 ||
+        msg.pollCreationMessageV3 ||
+        msg.pollCreationMessageV5 ||
+        msg.pollUpdateMessage ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION) {
+        return WA_STANZA_MSG_TYPES.POLL;
+    }
+    if (msg.extendedTextMessage?.matchedText && msg.extendedTextMessage.matchedText.trim() !== '') {
+        return 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.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_SCHEDULE) {
+        return WA_STANZA_MSG_TYPES.TEXT;
+    }
+    return WA_STANZA_MSG_TYPES.MEDIA;
+}
+const REVOKED_REACTION_TEXT = '';
+export function resolveEditAttr(message, subtype) {
+    const msg = unwrapMessage(message);
+    if (msg.protocolMessage) {
+        const protocolType = msg.protocolMessage.type;
+        if (protocolType === proto.Message.ProtocolMessage.Type.REVOKE) {
+            return subtype === 'admin_revoke'
+                ? WA_EDIT_ATTRS.ADMIN_REVOKE
+                : WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        if (protocolType === proto.Message.ProtocolMessage.Type.MESSAGE_EDIT) {
+            return WA_EDIT_ATTRS.MESSAGE_EDIT;
+        }
+        return null;
+    }
+    if (msg.secretEncryptedMessage) {
+        const encType = msg.secretEncryptedMessage.secretEncType;
+        if (encType === proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT ||
+            encType === proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT) {
+            return WA_EDIT_ATTRS.MESSAGE_EDIT;
+        }
+    }
+    if (msg.editedMessage) {
+        return WA_EDIT_ATTRS.MESSAGE_EDIT;
+    }
+    if (msg.reactionMessage) {
+        if (msg.reactionMessage.text === REVOKED_REACTION_TEXT) {
+            return WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        return null;
+    }
+    if (msg.keepInChatMessage) {
+        if (msg.keepInChatMessage.key?.fromMe === true &&
+            msg.keepInChatMessage.keepType === proto.KeepType.UNDO_KEEP_FOR_ALL) {
+            return WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        return null;
+    }
+    if (msg.pinInChatMessage) {
+        return WA_EDIT_ATTRS.PIN_IN_CHAT;
+    }
+    return null;
+}
+export function resolveEncMediaType(message) {
+    const msg = unwrapMessage(message);
+    if (msg.imageMessage)
+        return WA_ENC_MEDIA_TYPES.IMAGE;
+    if (msg.stickerMessage)
+        return WA_ENC_MEDIA_TYPES.STICKER;
+    if (msg.locationMessage) {
+        return msg.locationMessage.isLive
+            ? WA_ENC_MEDIA_TYPES.LIVE_LOCATION
+            : WA_ENC_MEDIA_TYPES.LOCATION;
+    }
+    if (msg.contactMessage)
+        return WA_ENC_MEDIA_TYPES.VCARD;
+    if (msg.contactsArrayMessage)
+        return WA_ENC_MEDIA_TYPES.CONTACT_ARRAY;
+    if (msg.documentMessage)
+        return WA_ENC_MEDIA_TYPES.DOCUMENT;
+    if (msg.audioMessage) {
+        return msg.audioMessage.ptt ? WA_ENC_MEDIA_TYPES.PTT : WA_ENC_MEDIA_TYPES.AUDIO;
+    }
+    if (msg.videoMessage) {
+        return msg.videoMessage.gifPlayback ? WA_ENC_MEDIA_TYPES.GIF : WA_ENC_MEDIA_TYPES.VIDEO;
+    }
+    if (msg.ptvMessage)
+        return WA_ENC_MEDIA_TYPES.PTV;
+    if (msg.buttonsMessage)
+        return WA_ENC_MEDIA_TYPES.BUTTON;
+    if (msg.buttonsResponseMessage)
+        return WA_ENC_MEDIA_TYPES.BUTTON_RESPONSE;
+    if (msg.listMessage)
+        return WA_ENC_MEDIA_TYPES.LIST;
+    if (msg.listResponseMessage)
+        return WA_ENC_MEDIA_TYPES.LIST_RESPONSE;
+    if (msg.orderMessage)
+        return WA_ENC_MEDIA_TYPES.ORDER;
+    if (msg.productMessage)
+        return WA_ENC_MEDIA_TYPES.PRODUCT;
+    if (msg.groupInviteMessage)
+        return WA_ENC_MEDIA_TYPES.URL;
+    if (msg.interactiveResponseMessage)
+        return WA_ENC_MEDIA_TYPES.NATIVE_FLOW_RESPONSE;
+    if (msg.messageHistoryBundle)
+        return WA_ENC_MEDIA_TYPES.GROUP_HISTORY;
+    if (msg.extendedTextMessage?.matchedText && msg.extendedTextMessage.matchedText.trim() !== '') {
+        return WA_ENC_MEDIA_TYPES.URL;
+    }
+    return null;
+}
+export function resolveMetaAttrs(message) {
+    const msg = unwrapMessage(message);
+    let polltype;
+    let eventType;
+    let viewOnce;
+    if (msg.pollCreationMessage || msg.pollCreationMessageV2 || msg.pollCreationMessageV3) {
+        polltype = WA_POLL_META_TYPES.CREATION;
+    }
+    else if (msg.pollUpdateMessage) {
+        polltype = WA_POLL_META_TYPES.VOTE;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT) {
+        polltype = WA_POLL_META_TYPES.EDIT;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION) {
+        polltype = WA_POLL_META_TYPES.EDIT;
+    }
+    if (msg.eventMessage) {
+        eventType = WA_EVENT_META_TYPES.CREATION;
+    }
+    else if (msg.encEventResponseMessage) {
+        eventType = WA_EVENT_META_TYPES.RESPONSE;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
+        eventType = 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/esm/message/icdc.js

@@ -0,0 +1,76 @@
+import { sha256, toRawPubKey } from '../crypto/index.js';
+import { parseSignalAddressFromJid } from '../protocol/jid.js';
+import { concatBytes } from '../util/bytes.js';
+const ICDC_HASH_LENGTH = 8;
+const ICDC_FRESHNESS_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
+const DEVICE_LIST_METADATA_VERSION = 2;
+const EMPTY_KEY_HASH = new Uint8Array(ICDC_HASH_LENGTH);
+export async function computeDeviceKeyHash(identityKeys) {
+    if (identityKeys.length === 0) {
+        return EMPTY_KEY_HASH;
+    }
+    const rawKeys = new Array(identityKeys.length);
+    for (let i = 0; i < identityKeys.length; i += 1) {
+        rawKeys[i] =
+            identityKeys[i].byteLength === 33 ? toRawPubKey(identityKeys[i]) : identityKeys[i];
+    }
+    const combined = concatBytes(rawKeys);
+    const hash = await sha256(combined);
+    return hash.subarray(0, ICDC_HASH_LENGTH);
+}
+export async function resolveIcdcMeta(deviceJids, signalStore, updatedAtMs, localIdentity) {
+    if (deviceJids.length === 0) {
+        return null;
+    }
+    const addresses = new Array(deviceJids.length);
+    for (let i = 0; i < deviceJids.length; i += 1) {
+        addresses[i] = parseSignalAddressFromJid(deviceJids[i]);
+    }
+    const remoteKeys = await signalStore.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);
+    const timestamp = updatedAtMs !== undefined && Date.now() - updatedAtMs < ICDC_FRESHNESS_THRESHOLD_MS
+        ? Math.floor(updatedAtMs / 1000)
+        : undefined;
+    return { keyHash, timestamp };
+}
+export 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/esm/message/incoming.js

@@ -3,33 +3,13 @@ import { unpadPkcs7 } from './padding.js';
 import { proto } from '../proto.js';
 import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES } from '../protocol/constants.js';
 import { isBroadcastJid, isGroupJid, parseSignalAddressFromJid } from '../protocol/jid.js';
-import { buildInboundDeliveryReceiptNode, buildInboundMessageAckNode, buildInboundRetryReceiptNode } from '../transport/node/builders/message.js';
-import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
-import { toError } from '../util/primitives.js';
-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;
-}
+import { buildAckNode, buildReceiptNode } from '../transport/node/builders/global.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild } from '../transport/node/helpers.js';
+import { parseOptionalInt, toError } from '../util/primitives.js';
 function pickNextRetryCount(node) {
     const retryNode = 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 = parseOptionalInt(retryNode?.attrs.count);
+    if (!parsed || parsed < 1) {
         return 1;
     }
     return parsed + 1;
@@ -39,21 +19,26 @@ function buildIncomingEventRawNode(node) {
     if (!Array.isArray(nodeContent) || nodeContent.length === 0) {
         return node;
     }
-    let redacted = false;
-    const children = nodeContent.map((child) => {
-        if (child.tag !== 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 === 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.
@@ -105,46 +90,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, 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: toError(error).message
-        });
-    }
-}
 async function sendRetryReceiptForDecryptFailure(node, options, error, encType) {
     const stanzaId = node.attrs.id;
     const from = node.attrs.from;
@@ -162,7 +122,13 @@ async function sendRetryReceiptForDecryptFailure(node, options, error, encType)
     if (options.onDecryptFailure) {
         return options.onDecryptFailure(retryContext, error);
     }
-    const retryReceiptNode = buildInboundRetryReceiptNode(node, stanzaId, from, options.getMeJid?.(), pickNextRetryCount(node));
+    const retryReceiptNode = 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', {
@@ -186,15 +152,37 @@ async function sendRetryReceiptForDecryptFailure(node, options, error, encType)
 }
 async function decryptAndProcessEncNode(node, encNode, encType, senderJid, options, decrypt) {
     try {
-        const decryptedPayload = await decrypt(decodeNodeContentBase64OrBytes(encNode.content, 'message.enc'));
+        const senderAddress = parseSignalAddressFromJid(senderJid);
+        const decryptedPayload = await decrypt(decodeNodeContentBase64OrBytes(encNode.content, 'message.enc'), senderAddress);
         const unpaddedPlaintext = unpadPkcs7(decryptedPayload);
-        const message = normalizeIncomingDecryptedMessage(proto.Message.decode(unpaddedPlaintext));
-        await maybeProcessSenderKeyDistributionMessage(senderJid, message, options, node);
+        const decodedMessage = proto.Message.decode(unpaddedPlaintext);
+        const message = 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: 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: parseOptionalInt(node.attrs.t),
                 senderJid,
                 encryptionType: encType,
                 isGroupChat: chatJid ? isGroupJid(chatJid) : false,
@@ -225,57 +213,68 @@ export async function handleIncomingMessageAck(node, options) {
         return false;
     }
     let shouldSendStandardReceipt = true;
-    const encNodes = getNodeChildrenByTag(node, 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 !== 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: 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(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));
         }
     }
@@ -290,7 +289,13 @@ export async function handleIncomingMessageAck(node, options) {
         return true;
     }
     if (node.attrs.type === WA_MESSAGE_TYPES.MEDIA_NOTIFY) {
-        const ackNode = buildInboundMessageAckNode(node, id, from, options.getMeJid?.());
+        const ackNode = buildAckNode({
+            kind: 'message',
+            node,
+            id,
+            to: from,
+            from: options.getMeJid?.()
+        });
         options.logger.debug('sending inbound message ack', {
             id,
             to: from,
@@ -303,7 +308,12 @@ export async function handleIncomingMessageAck(node, options) {
     if (!shouldSendStandardReceipt) {
         return true;
     }
-    const receiptNode = buildInboundDeliveryReceiptNode(node, id, from);
+    const receiptNode = buildReceiptNode({
+        kind: 'delivery',
+        node,
+        id,
+        to: from
+    });
     options.logger.debug('sending inbound message receipt', {
         id,
         to: from,
@@ -313,6 +323,3 @@ export async function handleIncomingMessageAck(node, options) {
     await options.sendNode(receiptNode);
     return true;
 }
-function normalizeIncomingDecryptedMessage(message) {
-    return unwrapDeviceSentMessage(message) ?? message;
-}