libzapitu-rf 1.0.0-alpha.2 → 1.0.0-alpha.20

package/README.md

@@ -1,9 +1,35 @@
+<h1><img alt="Baileys logo" src="https://raw.githubusercontent.com/zapitu/libzapitu/refs/heads/rf/Media/logo.jpg" height="75"/></h1>
+
 # libzapitu-rf
 
 LibZapitu is a WebSockets-based TypeScript library for interacting with the WhatsApp Web API.
 
 It is forked from [Baileys](https://github.com/WhiskeySockets/Baileys) before the changes to ESM and implements better compatibility to the new privacy of phone numbers from Whatsapp.
 
+# To work with libzapitu it is needed:
+
+* It is suggested to restart the connections reading again their qrcode
+* Do not use `makeCacheableSignalKeystore` on MakeWASocket
+* Be sure that `getMessage` is implemented and working well
+
+# To use libzapitu
+
+## To use libzapitu
+
+```
+npm install libzapitu-rf
+```
+
+## To install libzapitu-rf in place of baileys
+
+To avoid renaming imports from baileys on your existing code you can use npm aliasing function.
+
+Example: if your code uses "baileys" on imports:
+
+```
+npm install baileys@npm:libzapitu-rf
+```
+
 # Sponsor the author 
 
 Work on this fork is mostly from [Renato Freitas](https://github.com/renatoiub)
@@ -180,7 +206,7 @@ WhatsApp provides a multi-device API that allows Baileys to be authenticated as
 > You can customize browser name if you connect with **QR-CODE**, with `Browser` constant, we have some browsers config, **see [here](https://baileys.whiskeysockets.io/types/BrowsersMap.html)**
 
 ```ts
-import makeWASocket from '@whiskeysockets/baileys'
+import makeWASocket from 'libzapitu-rf'
 
 const sock = makeWASocket({
     // can provide additional config here

package/WAProto/index.d.ts

@@ -52837,6 +52837,9 @@ export namespace proto {
 
         /** WebMessageInfo botTargetId */
         botTargetId?: (string|null);
+
+         /** view once message */
+        viewOnce?: (boolean|null);
     }
 
     /** Represents a WebMessageInfo. */

package/lib/Defaults/index.d.ts

@@ -5,6 +5,10 @@ export declare const DEFAULT_ORIGIN = "https://web.whatsapp.com";
 export declare const DEF_CALLBACK_PREFIX = "CB:";
 export declare const DEF_TAG_PREFIX = "TAG:";
 export declare const PHONE_CONNECTION_CB = "CB:Pong";
+export declare const WA_ADV_ACCOUNT_SIG_PREFIX: Buffer<ArrayBuffer>;
+export declare const WA_ADV_DEVICE_SIG_PREFIX: Buffer<ArrayBuffer>;
+export declare const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX: Buffer<ArrayBuffer>;
+export declare const WA_ADV_HOSTED_DEVICE_SIG_PREFIX: Buffer<ArrayBuffer>;
 export declare const WA_DEFAULT_EPHEMERAL: number;
 export declare const NOISE_MODE = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
 export declare const DICT_VERSION = 3;

package/lib/Defaults/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CACHE_TTLS = exports.INITIAL_PREKEY_COUNT = exports.MIN_PREKEY_COUNT = exports.MEDIA_KEYS = exports.MEDIA_HKDF_KEY_MAPPING = exports.MEDIA_PATH_MAP = exports.DEFAULT_CONNECTION_CONFIG = exports.PROCESSABLE_HISTORY_TYPES = exports.WA_CERT_DETAILS = exports.URL_REGEX = exports.NOISE_WA_HEADER = exports.KEY_BUNDLE_TYPE = exports.DICT_VERSION = exports.NOISE_MODE = exports.WA_DEFAULT_EPHEMERAL = exports.PHONE_CONNECTION_CB = exports.DEF_TAG_PREFIX = exports.DEF_CALLBACK_PREFIX = exports.DEFAULT_ORIGIN = exports.UNAUTHORIZED_CODES = void 0;
+exports.DEFAULT_CACHE_TTLS = exports.INITIAL_PREKEY_COUNT = exports.MIN_PREKEY_COUNT = exports.MEDIA_KEYS = exports.MEDIA_HKDF_KEY_MAPPING = exports.MEDIA_PATH_MAP = exports.DEFAULT_CONNECTION_CONFIG = exports.PROCESSABLE_HISTORY_TYPES = exports.WA_CERT_DETAILS = exports.URL_REGEX = exports.NOISE_WA_HEADER = exports.KEY_BUNDLE_TYPE = exports.DICT_VERSION = exports.NOISE_MODE = exports.WA_DEFAULT_EPHEMERAL = exports.WA_ADV_HOSTED_DEVICE_SIG_PREFIX = exports.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = exports.WA_ADV_DEVICE_SIG_PREFIX = exports.WA_ADV_ACCOUNT_SIG_PREFIX = exports.PHONE_CONNECTION_CB = exports.DEF_TAG_PREFIX = exports.DEF_CALLBACK_PREFIX = exports.DEFAULT_ORIGIN = exports.UNAUTHORIZED_CODES = void 0;
 const WAProto_1 = require("../../WAProto");
 const libsignal_1 = require("../Signal/libsignal");
 const Utils_1 = require("../Utils");
@@ -14,6 +14,10 @@ exports.DEFAULT_ORIGIN = 'https://web.whatsapp.com';
 exports.DEF_CALLBACK_PREFIX = 'CB:';
 exports.DEF_TAG_PREFIX = 'TAG:';
 exports.PHONE_CONNECTION_CB = 'CB:Pong';
+exports.WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+exports.WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+exports.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
+exports.WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
 exports.WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
 exports.NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
 exports.DICT_VERSION = 3;

package/lib/Socket/business.d.ts

@@ -18,9 +18,11 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     sendMessageAck: ({ tag, attrs, content }: BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
-    fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAMessageKey, oldestMsgTimestamp: number | import("long").default) => Promise<string>;
+    fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
+    fetchNewChatMessageCap: () => Promise<import("../Types").NewChatMessageCapInfo>;
+    fetchAccountReachoutTimelock: () => Promise<import("../Types").ReachoutTimelockState>;
     requestPlaceholderResend: (messageKey: import("../Types").WAMessageKey) => Promise<string | undefined>;
-    getPrivacyTokens: (jids: string[]) => Promise<any>;
+    getPrivacyTokens: (jids: string[], timestamp?: number) => Promise<any>;
     assertSessions: (jids: string[], force: boolean, lids?: string) => Promise<boolean>;
     relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, isretry }: import("../Types").MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../Types").MessageReceiptType) => Promise<void>;
@@ -39,6 +41,29 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("../WABinary").JidWithDevice[]>;
     updateMediaMessage: (message: import("../Types").WAProto.IWebMessageInfo) => Promise<import("../Types").WAProto.IWebMessageInfo>;
     sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo | undefined>;
+    newsletterCreate: (name: string, description?: string) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterUpdate: (jid: string, updates: import("../Types").NewsletterUpdate) => Promise<unknown>;
+    newsletterSubscribers: (jid: string) => Promise<{
+        subscribers: number;
+    }>;
+    newsletterMetadata: (type: "invite" | "jid", key: string) => Promise<import("../Types").NewsletterMetadata | null>;
+    newsletterFollow: (jid: string) => Promise<unknown>;
+    newsletterUnfollow: (jid: string) => Promise<unknown>;
+    newsletterMute: (jid: string) => Promise<unknown>;
+    newsletterUnmute: (jid: string) => Promise<unknown>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<unknown>;
+    newsletterUpdateDescription: (jid: string, description: string) => Promise<unknown>;
+    newsletterUpdatePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<unknown>;
+    newsletterRemovePicture: (jid: string) => Promise<unknown>;
+    newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
+    newsletterFetchMessages: (jid: string, count: number, since: number, after: number) => Promise<any>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    } | null>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
+    newsletterDemote: (jid: string, userJid: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
     groupMetadata: (jid: string) => Promise<import("../Types").GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<import("../Types").GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;

package/lib/Socket/chats.d.ts

@@ -85,6 +85,8 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    fetchAccountReachoutTimelock: () => Promise<import("../Types").ReachoutTimelockState>;
+    fetchNewChatMessageCap: () => Promise<import("../Types").NewChatMessageCapInfo>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
 };

package/lib/Socket/chats.js

@@ -537,38 +537,6 @@ const makeChatsSocket = (config) => {
             ]
             : undefined
     });
-    const handlePresenceUpdate = ({ tag, attrs, content }) => {
-        var _a;
-        let presence;
-        const jid = attrs.from;
-        const participant = attrs.participant || attrs.from;
-        if (shouldIgnoreJid(jid) && jid !== '@s.whatsapp.net') {
-            return;
-        }
-        if (tag === 'presence') {
-            presence = {
-                lastKnownPresence: attrs.type === 'unavailable' ? 'unavailable' : 'available',
-                lastSeen: attrs.last && attrs.last !== 'deny' ? +attrs.last : undefined
-            };
-        }
-        else if (Array.isArray(content)) {
-            const [firstChild] = content;
-            let type = firstChild.tag;
-            if (type === 'paused') {
-                type = 'available';
-            }
-            if (((_a = firstChild.attrs) === null || _a === void 0 ? void 0 : _a.media) === 'audio') {
-                type = 'recording';
-            }
-            presence = { lastKnownPresence: type };
-        }
-        else {
-            logger.error({ tag, attrs, content }, 'recv invalid presence node');
-        }
-        if (presence) {
-            ev.emit('presence.update', { id: jid, presences: { [participant]: presence } });
-        }
-    };
     const appPatch = async (patchCreate) => {
         const name = patchCreate.type;
         const myAppStateKeyId = authState.creds.myAppStateKeyId;
@@ -635,15 +603,15 @@ const makeChatsSocket = (config) => {
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
-                xmlns: 'w',
+                xmlns: 'abt',
                 type: 'get'
             },
             content: [
                 {
                     tag: 'props',
                     attrs: {
-                        protocol: '2',
-                        hash: ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.lastPropHash) || ''
+                        protocol: '1',
+                        ...(((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.lastPropHash) ? { hash: authState.creds.lastPropHash } : {})
                     }
                 }
             ]
@@ -793,7 +761,7 @@ const makeChatsSocket = (config) => {
                 keyStore: authState.keys,
                 logger,
                 options: config.options
-            })
+            }, authState)
         ]);
         if (((_c = (_b = msg.message) === null || _b === void 0 ? void 0 : _b.protocolMessage) === null || _c === void 0 ? void 0 : _c.appStateSyncKeyShare) && pendingAppStateSync) {
             await doAppStateSync();
@@ -812,8 +780,6 @@ const makeChatsSocket = (config) => {
             }
         }
     });
-    ws.on('CB:presence', handlePresenceUpdate);
-    ws.on('CB:chatstate', handlePresenceUpdate);
     ws.on('CB:ib,,dirty', async (node) => {
         const { attrs } = (0, WABinary_1.getBinaryNodeChild)(node, 'dirty');
         const type = attrs.type;

package/lib/Socket/groups.d.ts

@@ -125,6 +125,8 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    fetchAccountReachoutTimelock: () => Promise<import("../Types").ReachoutTimelockState>;
+    fetchNewChatMessageCap: () => Promise<import("../Types").NewChatMessageCapInfo>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
 };

package/lib/Socket/index.d.ts

@@ -17,9 +17,11 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendMessageAck: ({ tag, attrs, content }: import("..").BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: import("..").BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
-    fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAMessageKey, oldestMsgTimestamp: number | import("long").default) => Promise<string>;
+    fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
+    fetchNewChatMessageCap: () => Promise<import("../Types").NewChatMessageCapInfo>;
+    fetchAccountReachoutTimelock: () => Promise<import("../Types").ReachoutTimelockState>;
     requestPlaceholderResend: (messageKey: import("../Types").WAMessageKey) => Promise<string | undefined>;
-    getPrivacyTokens: (jids: string[]) => Promise<any>;
+    getPrivacyTokens: (jids: string[], timestamp?: number) => Promise<any>;
     assertSessions: (jids: string[], force: boolean, lids?: string) => Promise<boolean>;
     relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, isretry }: import("../Types").MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../Types").MessageReceiptType) => Promise<void>;
@@ -38,6 +40,29 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("..").JidWithDevice[]>;
     updateMediaMessage: (message: import("../Types").WAProto.IWebMessageInfo) => Promise<import("../Types").WAProto.IWebMessageInfo>;
     sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo | undefined>;
+    newsletterCreate: (name: string, description?: string) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterUpdate: (jid: string, updates: import("../Types").NewsletterUpdate) => Promise<unknown>;
+    newsletterSubscribers: (jid: string) => Promise<{
+        subscribers: number;
+    }>;
+    newsletterMetadata: (type: "invite" | "jid", key: string) => Promise<import("../Types").NewsletterMetadata | null>;
+    newsletterFollow: (jid: string) => Promise<unknown>;
+    newsletterUnfollow: (jid: string) => Promise<unknown>;
+    newsletterMute: (jid: string) => Promise<unknown>;
+    newsletterUnmute: (jid: string) => Promise<unknown>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<unknown>;
+    newsletterUpdateDescription: (jid: string, description: string) => Promise<unknown>;
+    newsletterUpdatePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<unknown>;
+    newsletterRemovePicture: (jid: string) => Promise<unknown>;
+    newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
+    newsletterFetchMessages: (jid: string, count: number, since: number, after: number) => Promise<any>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    } | null>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
+    newsletterDemote: (jid: string, userJid: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
     groupMetadata: (jid: string) => Promise<import("../Types").GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<import("../Types").GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;

package/lib/Socket/messages-recv.d.ts

@@ -1,15 +1,17 @@
 import { Boom } from '@hapi/boom';
 import Long = require('long');
 import { proto } from '../../WAProto';
-import { MessageReceiptType, MessageRelayOptions, SocketConfig, WAMessageKey } from '../Types';
+import { MessageReceiptType, MessageRelayOptions, SocketConfig, WAMessageKey, WAPresence } from '../Types';
 import { BinaryNode } from '../WABinary';
 export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     sendMessageAck: ({ tag, attrs, content }: BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     fetchMessageHistory: (count: number, oldestMsgKey: WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
+    fetchNewChatMessageCap: () => Promise<import("../Types").NewChatMessageCapInfo>;
+    fetchAccountReachoutTimelock: () => Promise<import("../Types").ReachoutTimelockState>;
     requestPlaceholderResend: (messageKey: WAMessageKey) => Promise<string | undefined>;
-    getPrivacyTokens: (jids: string[]) => Promise<any>;
+    getPrivacyTokens: (jids: string[], timestamp?: number) => Promise<any>;
     assertSessions: (jids: string[], force: boolean, lids?: string) => Promise<boolean>;
     relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, isretry }: MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: MessageReceiptType) => Promise<void>;
@@ -28,6 +30,29 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("../WABinary").JidWithDevice[]>;
     updateMediaMessage: (message: proto.IWebMessageInfo) => Promise<proto.IWebMessageInfo>;
     sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<proto.WebMessageInfo | undefined>;
+    newsletterCreate: (name: string, description?: string) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterUpdate: (jid: string, updates: import("../Types").NewsletterUpdate) => Promise<unknown>;
+    newsletterSubscribers: (jid: string) => Promise<{
+        subscribers: number;
+    }>;
+    newsletterMetadata: (type: "invite" | "jid", key: string) => Promise<import("../Types").NewsletterMetadata | null>;
+    newsletterFollow: (jid: string) => Promise<unknown>;
+    newsletterUnfollow: (jid: string) => Promise<unknown>;
+    newsletterMute: (jid: string) => Promise<unknown>;
+    newsletterUnmute: (jid: string) => Promise<unknown>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<unknown>;
+    newsletterUpdateDescription: (jid: string, description: string) => Promise<unknown>;
+    newsletterUpdatePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<unknown>;
+    newsletterRemovePicture: (jid: string) => Promise<unknown>;
+    newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
+    newsletterFetchMessages: (jid: string, count: number, since: number, after: number) => Promise<any>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    } | null>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
+    newsletterDemote: (jid: string, userJid: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
     groupMetadata: (jid: string) => Promise<import("../Types").GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<import("../Types").GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
@@ -66,7 +91,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     };
     upsertMessage: (msg: import("../Types").WAMessage, type: import("../Types").MessageUpsertType) => Promise<void>;
     appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>;
-    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string) => Promise<void>;
+    sendPresenceUpdate: (type: WAPresence, toJid?: string) => Promise<void>;
     presenceSubscribe: (toJid: string, tcToken?: Buffer) => Promise<void>;
     profilePictureUrl: (jid: string, type?: "preview" | "image", timeoutMs?: number) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{

package/lib/Socket/messages-recv.js

@@ -18,7 +18,7 @@ const messages_send_1 = require("./messages-send");
 const makeMessagesRecvSocket = (config) => {
     const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid } = config;
     const sock = (0, messages_send_1.makeMessagesSocket)(config);
-    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage } = sock;
+    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, fetchAccountReachoutTimelock, fetchNewChatMessageCap } = sock;
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = (0, make_mutex_1.makeMutex)();
     const msgRetryCache = config.msgRetryCounterCache ||
@@ -87,7 +87,7 @@ const makeMessagesRecvSocket = (config) => {
         await query(stanza);
     };
     const sendRetryRequest = async (node, forceIncludeKeys = false) => {
-        const { fullMessage } = (0, Utils_1.decodeMessageNode)(node, authState.creds.me.id, authState.creds.me.lid || '');
+        const { fullMessage, author } = (0, Utils_1.decodeMessageNode)(node, authState.creds.me.id, authState.creds.me.lid || '');
         const { key: msgKey } = fullMessage;
         const msgId = msgKey.id;
         const key = `${msgId}:${msgKey === null || msgKey === void 0 ? void 0 : msgKey.participant}`;
@@ -138,7 +138,8 @@ const makeMessagesRecvSocket = (config) => {
             if (node.attrs.participant) {
                 receipt.attrs.participant = node.attrs.participant;
             }
-            if (retryCount > 1 || forceIncludeKeys) {
+            if (retryCount <= 2 && forceIncludeKeys) {
+                await assertSessions([(0, WABinary_1.jidNormalizedUser)(author)], true);
                 const { update, preKeys } = await (0, Utils_1.getNextPreKeys)(authState, 1);
                 const [keyId] = Object.keys(preKeys);
                 const key = preKeys[+keyId];
@@ -293,6 +294,7 @@ const makeMessagesRecvSocket = (config) => {
         const from = (0, WABinary_1.jidNormalizedUser)(node.attrs.from);
         switch (nodeType) {
             case 'privacy_token':
+                await handlePrivacyTokenNotification(node);
                 const tokenList = (0, WABinary_1.getBinaryNodeChildren)(child, 'token');
                 for (const { attrs, content } of tokenList) {
                     const jid = attrs.jid;
@@ -442,6 +444,32 @@ const makeMessagesRecvSocket = (config) => {
                 });
                 authState.creds.registered = true;
                 ev.emit('creds.update', authState.creds);
+                break;
+            case 'passkey_prologue_request': {
+                const optsNode = (0, WABinary_1.getBinaryNodeChild)(node, 'passkey_request_options');
+                let publicKey;
+                const content = optsNode === null || optsNode === void 0 ? void 0 : optsNode.content;
+                if (content instanceof Buffer || content instanceof Uint8Array) {
+                    publicKey = content;
+                }
+                else if (typeof content === 'string') {
+                    try {
+                        publicKey = JSON.parse(content);
+                    }
+                    catch (_d) {
+                        publicKey = Buffer.from(content, 'utf-8');
+                    }
+                }
+                ev.emit('pair.passkey.request', { publicKey, raw: node });
+                logger.info('passkey_prologue_request — use WhatsApp Web + extensão');
+                break;
+            }
+            case 'crsc_continuation': {
+                const primaryNode = (0, WABinary_1.getBinaryNodeChild)(node, 'primary_ephemeral_identity');
+                ev.emit('pair.passkey.confirmation', { raw: node });
+                logger.info({ hasPrimary: !!primaryNode }, 'passkey continuation (crsc_continuation)');
+                break;
+            }
         }
         if (Object.keys(result).length) {
             return result;
@@ -514,7 +542,7 @@ const makeMessagesRecvSocket = (config) => {
             fromMe,
             participant: attrs.participant
         };
-        if (shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
+        if (remoteJid && shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
             logger.debug({ remoteJid }, 'ignoring receipt from jid');
             await sendMessageAck(node);
             return;
@@ -614,12 +642,21 @@ const makeMessagesRecvSocket = (config) => {
         }
     };
     const handleMessage = async (node) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         if (shouldIgnoreJid(node.attrs.from) && node.attrs.from !== '@s.whatsapp.net') {
             logger.debug({ key: node.attrs.key }, 'ignored message');
             await sendMessageAck(node);
             return;
         }
+        const checkisValid = (0, WABinary_1.getBinaryNodeChild)(node, 'unavailable');
+        if (checkisValid && checkisValid.attrs.type === 'view_once') {
+            logger.debug({ key: node.attrs.key }, 'ignored msmsg viewOnce message');
+            const { fullMessage } = (0, Utils_1.decodeMessageNode)(node, authState.creds.me.id, authState.creds.me.lid || '');
+            fullMessage.viewOnce = true;
+            await upsertMessage(fullMessage, 'append');
+            await sendMessageAck(node);
+            return;
+        }
         const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc');
         // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
         if (encNode && encNode.attrs.type === 'msmsg') {
@@ -655,6 +692,12 @@ const makeMessagesRecvSocket = (config) => {
             node.attrs.sender_pn) {
             ev.emit('chats.phoneNumberShare', { lid: node.attrs.from, jid: node.attrs.sender_pn });
         }
+        if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
+            if (((_d = msg === null || msg === void 0 ? void 0 : msg.messageStubParameters) === null || _d === void 0 ? void 0 : _d[0]) === Utils_1.MISSING_KEYS_ERROR_TEXT ||
+                ((_e = msg.messageStubParameters) === null || _e === void 0 ? void 0 : _e[0]) === Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT) {
+                return sendMessageAck(node);
+            }
+        }
         try {
             await Promise.all([
                 processingMutex.mutex(async () => {
@@ -671,7 +714,7 @@ const makeMessagesRecvSocket = (config) => {
                                     return;
                                 }
                                 const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc');
-                                await sendRetryRequest(node, !encNode);
+                                await sendRetryRequest(node, true);
                                 if (retryRequestDelayMs) {
                                     await (0, Utils_1.delay)(retryRequestDelayMs);
                                 }
@@ -715,6 +758,7 @@ const makeMessagesRecvSocket = (config) => {
             ]);
         }
         catch (error) {
+            sendMessageAck(node);
             logger.error({ error, node }, 'error in handling message');
         }
     };
@@ -812,6 +856,40 @@ const makeMessagesRecvSocket = (config) => {
         ev.emit('call', [call]);
         await sendMessageAck(node);
     };
+    /** tracks message IDs that have already been retried for error 463 — prevents retry loops */
+    const tcTokenRetriedMsgIds = new Set();
+    /** tracks JIDs for which we have stored tctokens — used for periodic pruning */
+    const tcTokenKnownJids = new Set();
+    const retryMissingTcToken = async (key, msgId, jid) => {
+        if (!msgId || !jid || tcTokenRetriedMsgIds.has(msgId)) {
+            if (msgId && tcTokenRetriedMsgIds.has(msgId)) {
+                logger.warn({ msgId, from: jid }, 'error 463: already retried, giving up');
+            }
+            return false;
+        }
+        // Each entry auto-expires via setTimeout(60s), so the set
+        // is naturally bounded under normal conditions.
+        tcTokenRetriedMsgIds.add(msgId);
+        setTimeout(() => tcTokenRetriedMsgIds.delete(msgId), 60000);
+        const msg = await getMessage(key);
+        if (!msg) {
+            logger.warn({ msgId, from: jid }, 'error 463: no message found for retry');
+            return false;
+        }
+        try {
+            await (0, Utils_1.delay)(1500);
+            await relayMessage(jid, msg, {
+                messageId: msgId,
+                useUserDevicesCache: true
+            });
+            logger.info({ msgId, from: jid }, 'error 463 retry succeeded');
+            return true;
+        }
+        catch (retryErr) {
+            logger.warn({ msgId, err: retryErr === null || retryErr === void 0 ? void 0 : retryErr.message }, 'error 463 retry failed');
+            return false;
+        }
+    };
     const handleBadAck = async ({ attrs }) => {
         const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id };
         // WARNING: REFRAIN FROM ENABLING THIS FOR NOW. IT WILL CAUSE A LOOP
@@ -830,7 +908,41 @@ const makeMessagesRecvSocket = (config) => {
         // error in acknowledgement,
         // device could not display the message
         if (attrs.error) {
-            logger.warn({ attrs }, 'received error in ack');
+            if (attrs.error === Utils_1.SERVER_ERROR_CODES.MissingTcToken) {
+                const reachoutTimeLock = await fetchAccountReachoutTimelock().catch(err => {
+                    logger.warn({ err: err === null || err === void 0 ? void 0 : err.message }, 'failed to fetch reachout timelock after error 463');
+                    return undefined;
+                });
+                await fetchNewChatMessageCap().catch(err => {
+                    logger.debug({ err: err === null || err === void 0 ? void 0 : err.message }, 'failed to fetch new chat message cap after error 463');
+                });
+                if (reachoutTimeLock === null || reachoutTimeLock === void 0 ? void 0 : reachoutTimeLock.isActive) {
+                    ev.emit('messages.update', [
+                        {
+                            key,
+                            update: {
+                                status: Types_1.WAMessageStatus.ERROR,
+                                messageStubParameters: [attrs.error, Utils_1.ACCOUNT_RESTRICTED_TEXT]
+                            }
+                        }
+                    ]);
+                    return;
+                }
+                // Single retry: the original getPrivacyTokens IQ triggered token issuance.
+                // After a brief delay the server should have pushed a privacy_token
+                // notification, making the re-send succeed.
+                const msgId = attrs.id;
+                const jid = (0, WABinary_1.jidNormalizedUser)(attrs.from);
+                if (await retryMissingTcToken(key, msgId, jid)) {
+                    return;
+                }
+            }
+            else if (attrs.error === Utils_1.SERVER_ERROR_CODES.SmaxInvalid) {
+                logger.warn({ msgId: attrs.id, from: attrs.from }, 'smax-invalid (479): stanza rejected by server — likely stale device session or malformed addressing');
+            }
+            else {
+                logger.warn({ attrs }, 'received error in ack');
+            }
             ev.emit('messages.update', [
                 {
                     key,
@@ -879,7 +991,10 @@ const makeMessagesRecvSocket = (config) => {
                 }
                 isProcessing = false;
             };
-            promise().catch(error => onUnexpectedError(error, 'processing offline nodes'));
+            promise().catch(error => {
+                onUnexpectedError(error, 'processing offline nodes');
+                sendMessageAck(node);
+            });
         };
         return { enqueue };
     };
@@ -1027,6 +1142,61 @@ const makeMessagesRecvSocket = (config) => {
                 break;
         }
     }
+    const handlePrivacyTokenNotification = async (node) => {
+        const tokensNode = (0, WABinary_1.getBinaryNodeChild)(node, 'tokens');
+        const from = (0, WABinary_1.jidNormalizedUser)(node.attrs.from);
+        const issueTimestamp = (0, Utils_1.unixTimestampSeconds)();
+        if (!tokensNode)
+            return;
+        const tokenNodes = (0, WABinary_1.getBinaryNodeChildren)(tokensNode, 'token');
+        for (const tokenNode of tokenNodes) {
+            const { attrs, content } = tokenNode;
+            const type = attrs.type;
+            const timestamp = attrs.t;
+            if (type === 'trusted_contact' && content instanceof Buffer) {
+                logger.debug({
+                    from,
+                    timestamp,
+                    tcToken: content
+                }, 'received trusted contact token');
+                await authState.keys.set({
+                    'contacts-tc-token': { [from]: { token: content, timestamp, senderTimestamp: issueTimestamp } }
+                });
+            }
+        }
+    };
+    const handlePresenceUpdate = ({ tag, attrs, content }) => {
+        var _a;
+        let presence;
+        const jid = attrs.from;
+        const participant = attrs.participant || attrs.from;
+        if (shouldIgnoreJid(jid)) {
+            return;
+        }
+        if (tag === 'presence') {
+            presence = {
+                lastKnownPresence: attrs.type === 'unavailable' ? 'unavailable' : 'available',
+                lastSeen: attrs.last && attrs.last !== 'deny' ? +attrs.last : undefined
+            };
+        }
+        else if (Array.isArray(content)) {
+            const [firstChild] = content;
+            let type = firstChild.tag;
+            if (type === 'paused') {
+                type = 'available';
+            }
+            if (((_a = firstChild.attrs) === null || _a === void 0 ? void 0 : _a.media) === 'audio') {
+                type = 'recording';
+            }
+            presence = { lastKnownPresence: type };
+        }
+        else {
+            logger.error({ tag, attrs, content }, 'recv invalid presence node');
+        }
+        if (presence) {
+            ev.emit('presence.update', { id: jid, presences: { [participant]: presence } });
+        }
+    };
     // recv a message
     ws.on('CB:message', (node) => {
         processNode('message', node, 'processing message', handleMessage);
@@ -1043,6 +1213,8 @@ const makeMessagesRecvSocket = (config) => {
     ws.on('CB:ack,class:message', (node) => {
         handleBadAck(node).catch(error => onUnexpectedError(error, 'handling bad ack'));
     });
+    ws.on('CB:presence', handlePresenceUpdate);
+    ws.on('CB:chatstate', handlePresenceUpdate);
     ev.on('call', ([call]) => {
         // missed call + group call notification message generation
         if (call.status === 'timeout' || (call.status === 'offer' && call.isGroup)) {
@@ -1083,6 +1255,8 @@ const makeMessagesRecvSocket = (config) => {
         sendRetryRequest,
         rejectCall,
         fetchMessageHistory,
+        fetchNewChatMessageCap,
+        fetchAccountReachoutTimelock,
         requestPlaceholderResend
     };
 };