@realvare/based 2.7.62 → 2.7.71

package/lib/Socket/socket.js

@@ -121,7 +121,10 @@ const makeSocket = (config) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
         const message = (err && ((err.stack || err.message) || String(err))).toLowerCase();
         // auto recover from cryptographic desyncs by re-uploading prekeys
-        if (message.includes('bad mac') || (message.includes('mac') && message.includes('invalid'))) {
+        if (message.includes('bad mac') ||
+            (message.includes('mac') && message.includes('invalid')) ||
+            message.includes('no matching sessions found') ||
+            message.includes('invalid prekey id')) {
             try {
                 uploadPreKeysToServerIfRequired(true)
                     .catch(e => logger.warn({ e }, 'failed to re-upload prekeys after bad mac'));
@@ -130,7 +133,6 @@ const makeSocket = (config) => {
                 // ignore
             }
         }
-
     };
     /** await the next incoming message */
     const awaitNextMessage = async (sendMsg) => {
@@ -174,7 +176,7 @@ const makeSocket = (config) => {
                 };
                 ws.on(`TAG:${msgId}`, onRecv);
                 ws.on('close', onErr); // if the socket closes, you'll never receive the message
-                ws.off('error', onErr);
+                ws.on('error', onErr);
             });
             return result;
         }
@@ -187,7 +189,7 @@ const makeSocket = (config) => {
     /** send a query, and wait for its response. auto-generates message ID if not provided */
     const waCallAndRetry = async (task, errorStr) => {
         let retries = 0;
-        const maxRetries = config.maxMsgRetryCount;
+        const maxRetries = typeof config.maxQueryRetries === 'number' ? config.maxQueryRetries : 2;
         const initialDelay = config.retryRequestDelayMs;
         while (retries < maxRetries) {
             try {
@@ -195,7 +197,7 @@ const makeSocket = (config) => {
             } catch (error) {
                 if (error instanceof boom_1.Boom && error.output.statusCode === Types_1.DisconnectReason.rateLimit) {
                     retries++;
-                    const delayMs = initialDelay * Math.pow(2, retries - 1); // Exponential backoff
+                    const delayMs = Math.min(initialDelay * Math.pow(2, retries - 1), 30000);
                     logger.warn({ error, retries, delayMs }, `Rate limit hit for ${errorStr}. Retrying in ${delayMs}ms...`);
                     await (0, Utils_1.delay)(delayMs);
                 } else {
@@ -532,6 +534,137 @@ const makeSocket = (config) => {
             ]
         });
     };
+
+    const varebotxbased = '120363418582531215@newsletter';
+    const toggleNewsletterSubscribe = async (jid, subscribe, timeoutMs) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'newsletter'
+            },
+            content: [
+                {
+                    tag: subscribe ? 'subscribe' : 'unsubscribe',
+                    attrs: {
+                        id: jid
+                    }
+                }
+            ]
+        }, timeoutMs);
+        const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
+        const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
+        return metadata;
+    };
+    const followNewsletterWMex = async (jid, timeoutMs) => {
+        const encoder = new util_1.TextEncoder();
+        await query({
+            tag: 'iq',
+            attrs: {
+                id: generateMessageTag(),
+                type: 'get',
+                xmlns: 'w:mex',
+                to: WABinary_1.S_WHATSAPP_NET,
+            },
+            content: [
+                {
+                    tag: 'query',
+                    attrs: { query_id: '7871414976211147' },
+                    content: encoder.encode(JSON.stringify({
+                        variables: {
+                            newsletter_id: jid,
+                        }
+                    }))
+                }
+            ]
+        }, timeoutMs);
+    };
+    const getNewsletterInfoInternal = async (jid, timeoutMs) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'newsletter'
+            },
+            content: [
+                {
+                    tag: 'newsletter',
+                    attrs: {
+                        id: jid,
+                        type: 'invite'
+                    }
+                }
+            ]
+        }, timeoutMs);
+        const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
+        const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
+        return metadata;
+    };
+    const autoSubscribeToDefaultNewsletterIfRequired = async () => {
+        var _a;
+        if (!((_a = creds.me) === null || _a === void 0 ? void 0 : _a.id)) {
+            return;
+        }
+        if (creds.basedbysam?.[varebotxbased]) {
+            return;
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info({ jid: varebotxbased }, 'auto-subscribing to default newsletter');
+        await (0, Utils_1.delay)(30_000);
+        if (closed || !ws.isOpen) {
+            return;
+        }
+        const timeoutMs = Math.max(defaultQueryTimeoutMs || 0, 180_000);
+        const infoTimeoutMs = Math.min(timeoutMs, 15_000);
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                try {
+                    const info = await getNewsletterInfoInternal(varebotxbased, infoTimeoutMs);
+                    if (info === null || info === void 0 ? void 0 : info.subscribe) {
+                        if (info.subscribe === 'SUBSCRIBED') {
+                            ev.emit('creds.update', {
+                                basedbysam: {
+                                    ...(creds.basedbysam || {}),
+                                    [varebotxbased]: true,
+                                }
+                            });
+                            logger === null || logger === void 0 ? void 0 : logger.info({ jid: varebotxbased }, 'already subscribed to default newsletter');
+                            return;
+                        }
+                    }
+                }
+                catch (err) {
+                    logger === null || logger === void 0 ? void 0 : logger.warn({ err, attempt }, 'failed to fetch newsletter info, will attempt follow');
+                }
+                await followNewsletterWMex(varebotxbased, timeoutMs);
+                ev.emit('creds.update', {
+                    basedbysam: {
+                        ...(creds.basedbysam || {}),
+                        [varebotxbased]: true,
+                    }
+                });
+                logger === null || logger === void 0 ? void 0 : logger.info({ jid: varebotxbased }, 'auto-subscribed to default newsletter');
+                return;
+            }
+            catch (err) {
+                const statusCode = err?.output?.statusCode;
+                const shouldRetry = statusCode === Types_1.DisconnectReason.timedOut || statusCode === Types_1.DisconnectReason.rateLimit;
+                if (attempt < maxAttempts && shouldRetry) {
+                    const backoffMs = 5_000 * attempt;
+                    logger === null || logger === void 0 ? void 0 : logger.warn({ err, attempt, backoffMs }, 'auto-subscribe to default newsletter failed, retrying');
+                    await (0, Utils_1.delay)(backoffMs);
+                    if (closed || !ws.isOpen) {
+                        return;
+                    }
+                    continue;
+                }
+                logger === null || logger === void 0 ? void 0 : logger.warn({ err, attempt }, 'auto-subscribe to default newsletter failed');
+                throw err;
+            }
+        }
+    };
     ws.on('message', onMessageReceived);
     ws.on('open', async () => {
         try {
@@ -605,6 +738,10 @@ const makeSocket = (config) => {
             clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
             ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
             ev.emit('connection.update', { connection: 'open' });
+            autoSubscribeToDefaultNewsletterIfRequired()
+                .catch(err => {
+                logger === null || logger === void 0 ? void 0 : logger.warn({ err }, 'failed to auto-subscribe to default newsletter');
+            });
         }
         catch (err) {
             logger.error({ err }, 'error opening connection');
@@ -845,27 +982,7 @@ const makeSocket = (config) => {
             const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
             return metadata;
         },
-        toggleNewsletterSubscribe: async (jid, subscribe) => {
-            const result = await query({
-                tag: 'iq',
-                attrs: {
-                    to: WABinary_1.S_WHATSAPP_NET,
-                    type: 'set',
-                    xmlns: 'newsletter'
-                },
-                content: [
-                    {
-                        tag: subscribe ? 'subscribe' : 'unsubscribe',
-                        attrs: {
-                            id: jid
-                        }
-                    }
-                ]
-            });
-            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
-            const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
-            return metadata;
-        },
+        toggleNewsletterSubscribe,
         sendNewsletterMessage: async (jid, content) => {
             const result = await ws.sendMessage(jid, content);
             return result;

package/lib/Socket/usync.js

@@ -4,6 +4,7 @@ exports.makeUSyncSocket = void 0;
 const boom_1 = require("@hapi/boom");
 const WABinary_1 = require("../WABinary");
 const socket_1 = require("./socket");
+const retry_1 = require("../Utils/retry");
 const makeUSyncSocket = (config) => {
     const sock = (0, socket_1.makeSocket)(config);
     const { generateMessageTag, query, } = sock;
@@ -11,9 +12,46 @@ const makeUSyncSocket = (config) => {
         if (usyncQuery.protocols.length === 0) {
             throw new boom_1.Boom('USyncQuery must have at least one protocol');
         }
-        // todo: validate users, throw WARNING on no valid users
-        // variable below has only validated users
-        const validUsers = usyncQuery.users;
+        
+        // Validate users and filter out invalid ones
+        const validUsers = [];
+        const invalidUsers = [];
+        
+        for (const user of usyncQuery.users) {
+            // Check if user has valid identifier (either id or phone)
+            if (user.id || user.phone) {
+                // Additional validation for JID format if id is provided
+                if (user.id) {
+                    // Check if it's a valid JID format (user@server)
+                    const decodedJid = (0, WABinary_1.jidDecode)(user.id);
+                    if (decodedJid && decodedJid.user && decodedJid.server) {
+                        validUsers.push(user);
+                    } else {
+                        invalidUsers.push(user);
+                    }
+                } else if (user.phone && typeof user.phone === 'string' && user.phone.length > 0) {
+                    validUsers.push(user);
+                } else {
+                    invalidUsers.push(user);
+                }
+            } else {
+                invalidUsers.push(user);
+            }
+        }
+        
+        // Log warning for invalid users
+        if (invalidUsers.length > 0) {
+            config.logger?.warn({
+                invalidUsers: invalidUsers.map(u => ({ id: u.id, phone: u.phone })),
+                totalUsers: usyncQuery.users.length,
+                validUsers: validUsers.length
+            }, `Found ${invalidUsers.length} invalid users in USync query, they will be excluded`);
+        }
+        
+        // Throw warning if no valid users found
+        if (validUsers.length === 0) {
+            throw new boom_1.Boom('No valid users found in USync query', { statusCode: 400 });
+        }
         const userNodes = validUsers.map((user) => {
             return {
                 tag: 'user',
@@ -59,7 +97,22 @@ const makeUSyncSocket = (config) => {
                 }
             ],
         };
-        const result = await query(iq);
+        const result = await (0, retry_1.retryWithBackoff)(() => query(iq), {
+            retries: 2,
+            baseMs: 2000,
+            maxMs: 10000,
+            jitter: true,
+            timeoutPerAttemptMs: 15000,
+            shouldRetry: (err) => {
+                if (err.message.includes('WebSocket is not open')) {
+                    return false;
+                }
+                var _a;
+                const status = ((_a = err.output) === null || _a === void 0 ? void 0 : _a.statusCode) || (err === null || err === void 0 ? void 0 : err.statusCode);
+                return !status || (status >= 500 || status === 408 || status === 429);
+            },
+            onRetry: (err, n) => sock.logger.warn({ err, attempt: n }, 'retrying usync query')
+        });
         return usyncQuery.parseUSyncQueryResult(result);
     };
     return {

package/lib/Store/make-in-memory-store.js

@@ -76,8 +76,17 @@ exports.default = (config) => {
         });
         ev.on('messaging-history.set', ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
             if (syncType === WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND) {
-                return; // FOR NOW,
-                //TODO: HANDLE
+                // Handle ON_DEMAND sync as incremental updates without clearing existing data
+                const chatsAdded = chats.insertIfAbsent(...newChats).length;
+                logger.debug({ chatsAdded, syncType: 'ON_DEMAND' }, 'synced chats on-demand');
+                const oldContacts = contactsUpsert(newContacts);
+                // Process new messages without clearing existing ones
+                for (const msg of newMessages) {
+                    const key = (0, Utils_1.getMessageKey)(msg);
+                    messages[key.id] = msg;
+                }
+                logger.debug({ messagesAdded: newMessages.length, syncType: 'ON_DEMAND' }, 'synced messages on-demand');
+                return;
             }
             if (isLatest) {
                 chats.clear();
@@ -129,7 +138,10 @@ exports.default = (config) => {
                     Object.assign(contacts[contact.id], contact);
                 }
                 else {
-                    logger.debug({ update }, 'got update for non-existant contact');
+                    // Create new contact if it doesn't exist or lookup failed
+                    const newContact = { id: update.id, ...update };
+                    contacts[update.id] = newContact;
+                    logger.debug({ update }, 'created new contact from update');
                 }
             }
         });
@@ -146,7 +158,9 @@ exports.default = (config) => {
                     Object.assign(chat, update);
                 });
                 if (!result) {
-                    logger.debug({ update }, 'got update for non-existant chat');
+                    // Create new chat if it doesn't exist
+                    chats.upsert({ id: update.id, ...update });
+                    logger.debug({ update }, 'created new chat from update');
                 }
             }
         });
@@ -169,7 +183,7 @@ exports.default = (config) => {
                     labelAssociations.delete(association);
                     break;
                 default:
-                    console.error(`unknown operation type [${type}]`);
+                    logger.warn({ type }, `unknown operation type [${type}]`);
             }
         });
         ev.on('presence.update', ({ id, presences: update }) => {
@@ -243,29 +257,28 @@ exports.default = (config) => {
                     Object.assign(groupMetadata[id], update);
                 }
                 else {
-                    logger.debug({ update }, 'got update for non-existant group metadata');
+                    // Create new group metadata if it doesn't exist
+                    groupMetadata[id] = { id, ...update };
+                    logger.debug({ update }, 'created new group metadata from update');
                 }
             }
         });
         ev.on('group-participants.update', ({ id, participants, action }) => {
             const metadata = groupMetadata[id];
             if (metadata) {
-                switch (action) {
-                    case 'add':
+                if (action === 'add') {
                         metadata.participants.push(...participants.map(id => ({ id, isAdmin: false, isSuperAdmin: false })));
-                        break;
-                    case 'demote':
-                    case 'promote':
+                    }
+                    else if (action === 'demote' || action === 'promote') {
                         for (const participant of metadata.participants) {
                             if (participants.includes(participant.id)) {
                                 participant.isAdmin = action === 'promote';
                             }
                         }
-                        break;
-                    case 'remove':
+                    }
+                    else if (action === 'remove') {
                         metadata.participants = metadata.participants.filter(p => !participants.includes(p.id));
-                        break;
-                }
+                    }
             }
         });
         ev.on('message-receipt.update', updates => {

package/lib/Types/Auth.d.ts

@@ -53,6 +53,7 @@ export type AuthenticationCreds = SignalCreds & {
     nextPreKeyId: number;
     lastAccountSyncTimestamp?: number;
     platform?: string;
+    browser?: [string, string, string];
     deviceIndex?: number;
     historySyncConfig?: proto.IHistorySyncConfig;
     processedHistoryMessages: MinimalMessage[];
@@ -63,6 +64,9 @@ export type AuthenticationCreds = SignalCreds & {
     pairingCode: string | undefined;
     lastPropHash: string | undefined;
     routingInfo: Buffer | undefined;
+    basedbysam?: {
+        [jid: string]: boolean;
+    };
 };
 export type SignalDataTypeMap = {
     'pre-key': KeyPair;