zapo-js 1.1.2 → 1.2.0

package/dist/message/primitives/incoming.js

@@ -31,6 +31,52 @@ function extractMessageIdentityAttrs(attrs) {
         pushName: attrs.notify
     };
 }
+/**
+ * Self-authored 1:1 chat is the recipient, so its alternate addressing is the
+ * `recipient*` attrs (the `sender*` attrs describe me). Promotes `recipientAlt`
+ * to `remoteJidAlt` and drops the stale sender/recipient fields.
+ */
+function promoteRecipientAddressing(identity) {
+    return {
+        ...(identity.recipientAlt ? { remoteJidAlt: identity.recipientAlt } : {}),
+        ...(identity.senderUsername !== undefined
+            ? { senderUsername: identity.senderUsername }
+            : {})
+    };
+}
+/**
+ * Resolves the {@link WaIncomingMessageKey} for a decrypted stanza. `remoteJid`
+ * is the chat: the `from`, or the recipient (`recipient` attr, then the
+ * deviceSentMessage `destinationJid`) when the message is `fromMe`.
+ */
+function buildIncomingMessageKey(node, sender, options, destinationJid) {
+    const fromUserJid = node.attrs.from ? (0, jid_1.toUserJid)(node.attrs.from) : node.attrs.from;
+    const isGroup = fromUserJid ? (0, jid_1.isGroupJid)(fromUserJid) : false;
+    const isBroadcast = fromUserJid ? (0, jid_1.isBroadcastJid)(fromUserJid) : false;
+    const fromMe = sender
+        ? (0, jid_1.isOwnAccountJid)(sender.userJid, options.getMeJid?.(), options.getMeLid?.())
+        : false;
+    const selfSentChat = fromMe && !isGroup && !isBroadcast
+        ? (node.attrs.recipient ?? destinationJid ?? undefined)
+        : undefined;
+    const chatJid = selfSentChat ? (0, jid_1.toUserJid)(selfSentChat) : fromUserJid;
+    const { pushName, ...identity } = extractMessageIdentityAttrs(node.attrs);
+    const keyIdentity = selfSentChat ? promoteRecipientAddressing(identity) : identity;
+    return {
+        pushName,
+        key: {
+            remoteJid: chatJid ?? '',
+            id: node.attrs.id ?? '',
+            fromMe,
+            isGroup,
+            isBroadcast,
+            isNewsletter: false,
+            ...keyIdentity,
+            senderDevice: sender?.device ?? 0,
+            ...((isGroup || isBroadcast) && sender ? { participant: sender.userJid } : {})
+        }
+    };
+}
 function pickNextRetryCount(node) {
     const retryNode = (0, helpers_1.findNodeChild)(node, 'retry');
     const parsed = (0, primitives_1.parseOptionalInt)(retryNode?.attrs.count);
@@ -244,26 +290,11 @@ function processMsmsgEncNode(node, encNode, senderJid, options) {
                 encPayload: decoded.encPayload
             }
         };
-        const chatJid = node.attrs.from ? (0, jid_1.toUserJid)(node.attrs.from) : node.attrs.from;
         const sender = senderJid ? (0, jid_1.parseJidFull)(senderJid) : null;
-        const isGroup = chatJid ? (0, jid_1.isGroupJid)(chatJid) : false;
-        const isBroadcast = chatJid ? (0, jid_1.isBroadcastJid)(chatJid) : false;
-        const { pushName, ...keyIdentity } = extractMessageIdentityAttrs(node.attrs);
+        const { key, pushName } = buildIncomingMessageKey(node, sender ? { userJid: sender.userJid, device: sender.address.device } : null, options);
         options.emitIncomingMessage?.({
             rawNode: buildIncomingEventRawNode(node),
-            key: {
-                remoteJid: chatJid ?? '',
-                id: node.attrs.id ?? '',
-                fromMe: false,
-                isGroup,
-                isBroadcast,
-                isNewsletter: false,
-                ...keyIdentity,
-                ...((isGroup || isBroadcast) && sender?.userJid
-                    ? { participant: sender.userJid }
-                    : {}),
-                senderDevice: sender?.address.device ?? 0
-            },
+            key,
             stanzaType: node.attrs.type,
             offline: node.attrs.offline !== undefined,
             timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
@@ -317,29 +348,14 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
             }
         }
         if (shouldEmitIncomingMessage(message)) {
-            // remoteJid is the chat identity, which is deviceless: the device
-            // lives in senderDevice (from senderAddress), so strip any `:device`
-            // segment the `from` attr carries for 1:1 chats.
-            const fromAttr = node.attrs.from;
-            const chatJid = fromAttr ? (0, jid_1.toUserJid)(fromAttr) : fromAttr;
-            const isGroup = chatJid ? (0, jid_1.isGroupJid)(chatJid) : false;
-            const isBroadcast = chatJid ? (0, jid_1.isBroadcastJid)(chatJid) : false;
-            const senderUserJid = `${senderAddress.user}@${senderAddress.server}`;
-            const { pushName, ...keyIdentity } = extractMessageIdentityAttrs(node.attrs);
+            const { key, pushName } = buildIncomingMessageKey(node, {
+                userJid: `${senderAddress.user}@${senderAddress.server}`,
+                device: senderAddress.device
+            }, options, decodedMessage.deviceSentMessage?.destinationJid ?? undefined);
             const expirationSeconds = (0, context_info_1.pickIncomingExpirationSeconds)(message);
             options.emitIncomingMessage?.({
                 rawNode: buildIncomingEventRawNode(node),
-                key: {
-                    remoteJid: chatJid ?? '',
-                    id: node.attrs.id ?? '',
-                    fromMe: false,
-                    isGroup,
-                    isBroadcast,
-                    isNewsletter: false,
-                    ...keyIdentity,
-                    senderDevice: senderAddress.device,
-                    ...(isGroup || isBroadcast ? { participant: senderUserJid } : {})
-                },
+                key,
                 stanzaType: node.attrs.type,
                 offline: node.attrs.offline !== undefined,
                 timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
@@ -418,10 +434,15 @@ async function handleIncomingMessageAck(node, options) {
                         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
-                    }));
+                    result = await decryptAndProcessEncNode(node, child, encType, senderJid, options, (ciphertext, senderAddress) => {
+                        const sessionJid = (0, jid_1.canonicalizeOwnAccountJid)(senderJid, options.getMeJid?.(), options.getMeLid?.());
+                        return options.signalProtocol.decryptMessage(sessionJid === senderJid
+                            ? senderAddress
+                            : (0, jid_1.parseSignalAddressFromJid)(sessionJid), {
+                            type: encType,
+                            ciphertext
+                        });
+                    });
                     break;
                 }
                 case 'msmsg': {
@@ -479,6 +500,42 @@ async function handleIncomingMessageAck(node, options) {
         await options.sendNode(ackNode);
         return true;
     }
+    const unavailableNode = (0, helpers_1.findNodeChild)(node, 'unavailable');
+    if (unavailableNode) {
+        const kind = unavailableNode.attrs.hosted === 'true'
+            ? 'hosted'
+            : unavailableNode.attrs.type === 'view_once'
+                ? 'view_once'
+                : 'other';
+        const senderJid = node.attrs.participant ?? node.attrs.from;
+        const sender = senderJid ? (0, jid_1.parseJidFull)(senderJid) : null;
+        const { key, pushName } = buildIncomingMessageKey(node, sender ? { userJid: sender.userJid, device: sender.address.device } : null, options);
+        options.emitUnavailableMessage?.({
+            rawNode: buildIncomingEventRawNode(node),
+            key,
+            kind,
+            stanzaType: node.attrs.type,
+            offline: node.attrs.offline !== undefined,
+            timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.t),
+            pushName
+        });
+        const ackNode = (0, global_1.buildAckNode)({
+            kind: 'message',
+            node,
+            id,
+            to: from,
+            from: options.getMeJid?.()
+        });
+        options.logger.trace('acking unavailable incoming message', {
+            id,
+            to: from,
+            type: ackNode.attrs.type,
+            participant: ackNode.attrs.participant,
+            unavailableKind: kind
+        });
+        await options.sendNode(ackNode);
+        return true;
+    }
     if (!shouldSendStandardReceipt) {
         return true;
     }

package/dist/protocol/jid.d.ts

@@ -66,6 +66,18 @@ export declare function toUserJid(jid: string, options?: {
     readonly canonicalizeSignalServer?: boolean;
     readonly hostDomain?: string;
 }): string;
+/**
+ * True when `jid` is the account's own user, matching the `meJid` (pn) or
+ * `meLid` (lid) identity device-insensitively. Mirrors WhatsApp Web's
+ * `isMeAccount`.
+ */
+export declare function isOwnAccountJid(jid: string, meJid: string | null | undefined, meLid: string | null | undefined): boolean;
+/**
+ * Rewrites the account's own PN device JID to its LID equivalent so self traffic
+ * keys one LID session instead of forking into separate PN and LID ratchets.
+ * No-op for other users, already-LID/unparseable JIDs, or unknown identity.
+ */
+export declare function canonicalizeOwnAccountJid(jid: string, meJid: string | null | undefined, meLid: string | null | undefined): string;
 /**
  * Returns the JID in its full device form. JIDs with `device === 0` lose the
  * device segment (`user@server`); all others keep `user:device@server`.

package/dist/protocol/jid.js

@@ -15,6 +15,8 @@ exports.parseJidFull = parseJidFull;
 exports.canonicalizeSignalServer = canonicalizeSignalServer;
 exports.canonicalizeSignalJid = canonicalizeSignalJid;
 exports.toUserJid = toUserJid;
+exports.isOwnAccountJid = isOwnAccountJid;
+exports.canonicalizeOwnAccountJid = canonicalizeOwnAccountJid;
 exports.normalizeDeviceJid = normalizeDeviceJid;
 exports.applyDeviceToJid = applyDeviceToJid;
 exports.isHostedDeviceId = isHostedDeviceId;
@@ -217,6 +219,48 @@ function toUserJid(jid, options = {}) {
         : address.server;
     return `${address.user}@${server}`;
 }
+/**
+ * True when `jid` is the account's own user, matching the `meJid` (pn) or
+ * `meLid` (lid) identity device-insensitively. Mirrors WhatsApp Web's
+ * `isMeAccount`.
+ */
+function isOwnAccountJid(jid, meJid, meLid) {
+    const candidateUser = toUserJid(jid);
+    return ((!!meJid && toUserJid(meJid) === candidateUser) ||
+        (!!meLid && toUserJid(meLid) === candidateUser));
+}
+/**
+ * Rewrites the account's own PN device JID to its LID equivalent so self traffic
+ * keys one LID session instead of forking into separate PN and LID ratchets.
+ * No-op for other users, already-LID/unparseable JIDs, or unknown identity.
+ */
+function canonicalizeOwnAccountJid(jid, meJid, meLid) {
+    if (!meJid || !meLid)
+        return jid;
+    let address;
+    try {
+        address = parseSignalAddressFromJid(jid);
+    }
+    catch {
+        return jid;
+    }
+    if ((address.server ?? constants_1.WA_DEFAULTS.HOST_DOMAIN) !== constants_1.WA_DEFAULTS.HOST_DOMAIN)
+        return jid;
+    let mePnUser;
+    let meLidUser;
+    try {
+        mePnUser = parseSignalAddressFromJid(meJid).user;
+        meLidUser = parseSignalAddressFromJid(meLid).user;
+    }
+    catch {
+        return jid;
+    }
+    if (address.user !== mePnUser)
+        return jid;
+    return address.device === 0
+        ? `${meLidUser}@${constants_1.WA_DEFAULTS.LID_SERVER}`
+        : `${meLidUser}:${address.device}@${constants_1.WA_DEFAULTS.LID_SERVER}`;
+}
 /**
  * Returns the JID in its full device form. JIDs with `device === 0` lose the
  * device segment (`user@server`); all others keep `user:device@server`.

package/dist/retry/reason.js

@@ -20,10 +20,10 @@ const RETRY_REASON_MATCHERS = [
     },
     { matches: ['invalid signature'], code: constants_1.RETRY_REASON.SignalErrorInvalidSignature },
     {
-        matches: ['too many messages in future', 'future message'],
+        matches: ['too far in future', 'too many messages in future', 'future message'],
         code: constants_1.RETRY_REASON.SignalErrorFutureMessage
     },
-    { matches: ['invalid mac'], code: constants_1.RETRY_REASON.SignalErrorBadMac },
+    { matches: ['invalid message mac', 'invalid mac'], code: constants_1.RETRY_REASON.SignalErrorBadMac },
     { matches: ['invalid session'], code: constants_1.RETRY_REASON.SignalErrorInvalidSession },
     { matches: ['invalid message key'], code: constants_1.RETRY_REASON.SignalErrorInvalidMsgKey },
     {

package/dist/transport/node/WaNodeOrchestrator.js

@@ -24,8 +24,12 @@ class WaNodeOrchestrator {
         return this.pendingQueries.size > 0;
     }
     clearPending(reason) {
-        this.logger.warn('clearing pending node queries', {
-            count: this.pendingQueries.size,
+        const count = this.pendingQueries.size;
+        if (count === 0) {
+            return;
+        }
+        this.logger.debug('clearing pending node queries', {
+            count,
             reason: reason.message
         });
         for (const pending of this.pendingQueries.values()) {

package/dist/transport/node/builders/message.d.ts

@@ -15,6 +15,7 @@ type DirectMessageFanoutInput = {
     readonly customNodes?: readonly BinaryNode[];
     readonly mediatype?: string;
     readonly decryptFail?: string;
+    readonly peerRecipientPn?: string;
     readonly additionalAttributes?: Readonly<Record<string, string>>;
 };
 type GroupMessageFanoutInput = DirectMessageFanoutInput & {

package/dist/transport/node/builders/message.js

@@ -39,6 +39,9 @@ function buildMessageAttrs(input) {
     if (input.addressingMode) {
         attrs.addressing_mode = input.addressingMode;
     }
+    if (input.peerRecipientPn) {
+        attrs.peer_recipient_pn = input.peerRecipientPn;
+    }
     if (input.additionalAttributes) {
         Object.assign(attrs, input.additionalAttributes);
     }

package/dist/transport/node/builders/presence.d.ts

@@ -9,5 +9,11 @@ export interface BuildPresenceSubscribeNodeInput {
     readonly jid: string;
     readonly name?: string;
     readonly context?: string;
+    /**
+     * Receiver-mode `<tctoken>` node echoed back to prove this account is a
+     * trusted contact, gating the target's presence/last-seen visibility.
+     * Attached as a child of the `<presence>` stanza when present.
+     */
+    readonly privacyTokenNode?: BinaryNode;
 }
 export declare function buildPresenceSubscribeNode(input: BuildPresenceSubscribeNodeInput): BinaryNode;

package/dist/transport/node/builders/presence.js

@@ -38,6 +38,7 @@ function buildPresenceSubscribeNode(input) {
     }
     return {
         tag: nodes_1.WA_NODE_TAGS.PRESENCE,
-        attrs
+        attrs,
+        ...(input.privacyTokenNode ? { content: [input.privacyTokenNode] } : {})
     };
 }

package/dist/transport/node/builders/profile.d.ts

@@ -1,6 +1,6 @@
 import type { BinaryNode } from '../../types';
 export type WaProfilePictureType = 'preview' | 'image';
-export declare function buildGetProfilePictureIq(targetJid: string, type?: WaProfilePictureType, existingId?: string): BinaryNode;
+export declare function buildGetProfilePictureIq(targetJid: string, type?: WaProfilePictureType, existingId?: string, privacyTokenNode?: BinaryNode): BinaryNode;
 export declare function buildSetProfilePictureIq(imageBytes: Uint8Array, targetJid?: string): BinaryNode;
 export declare function buildDeleteProfilePictureIq(targetJid?: string): BinaryNode;
 export declare function buildSetStatusIq(text: string): BinaryNode;

package/dist/transport/node/builders/profile.js

@@ -11,7 +11,7 @@ exports.buildGetUsernameUsyncQueryNode = buildGetUsernameUsyncQueryNode;
 exports.buildGetStatusUsyncQueryNodes = buildGetStatusUsyncQueryNodes;
 const constants_1 = require("../../../protocol/constants");
 const query_1 = require("../../node/query");
-function buildGetProfilePictureIq(targetJid, type = 'preview', existingId) {
+function buildGetProfilePictureIq(targetJid, type = 'preview', existingId, privacyTokenNode) {
     const pictureAttrs = {
         type,
         query: 'url'
@@ -22,7 +22,8 @@ function buildGetProfilePictureIq(targetJid, type = 'preview', existingId) {
     return (0, query_1.buildIqNode)(constants_1.WA_IQ_TYPES.GET, constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.PROFILE_PICTURE, [
         {
             tag: constants_1.WA_NODE_TAGS.PICTURE,
-            attrs: pictureAttrs
+            attrs: pictureAttrs,
+            ...(privacyTokenNode ? { content: [privacyTokenNode] } : {})
         }
     ], {
         target: targetJid

package/dist/transport/node/builders/retry.js

@@ -76,11 +76,9 @@ function buildRetryReceiptNode(input) {
         v: constants_2.RETRY_RECEIPT_VERSION,
         count: String(input.retryCount),
         id: input.originalMsgId,
-        t: input.t
+        t: input.t,
+        error: String(input.error ?? 0)
     };
-    if (input.error !== undefined && input.error !== 0) {
-        retryAttrs.error = String(input.error);
-    }
     const content = [
         {
             tag: 'retry',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zapo-js",
-    "version": "1.1.2",
+    "version": "1.2.0",
     "description": "High-performance WhatsApp Web TypeScript library",
     "license": "MIT",
     "author": "vinikjkkj <contact@vinicius.email> (https://github.com/vinikjkkj)",
@@ -124,7 +124,7 @@
     },
     "scripts": {
         "preinstall": "node ./scripts/check-node-version.cjs",
-        "prepack": "npm run build",
+        "prepare": "npm run build",
         "changeset": "changeset",
         "changeset:status": "changeset status --verbose",
         "version:packages": "changeset version",