@realvare/based 2.7.61 → 2.7.70

package/lib/Socket/socket.js

@@ -174,7 +174,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;
         }

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/Message.d.ts

@@ -18,6 +18,8 @@ export type WAMessageKey = proto.IMessageKey & {
     senderPn?: string;
     senderLid?: string;
     participantLid?: string;
+    remoteLid?: string;
+    remoteJidNormalized?: string;
     server_id?: string;
     isViewOnce?: boolean;
 };
@@ -31,6 +33,9 @@ export interface StickerPackMessage {
     description?: string;
     cover?: WAMediaUpload;
     stickers: Sticker[];
+    stickerPackId?: string;
+    origin?: 0 | 1 | 2; // FIRST_PARTY = 0, THIRD_PARTY = 1, USER_CREATED = 2
+    caption?: string;
 }
 export interface Sticker {
     sticker: WAMediaUpload;
@@ -102,6 +107,13 @@ type Interactiveable = {
     title?: string;
     subtitle?: string;
     media?: boolean;
+    /** Footer with optional audio attachment */
+    footer?: string | {
+        text: string;
+        audio?: WAMediaUpload;
+    };
+    /** Product message in header */
+    headerProduct?: WASendableProduct;
 };
 type Shopable = {
     shop?: proto.Message.InteractiveMessage.ShopMessage.Surface;
@@ -110,9 +122,26 @@ type Shopable = {
     subtitle?: string;
     media?: boolean;
 };
+type Collectionable = {
+    collection?: {
+        bizJid: string;
+        id: string;
+        messageVersion?: number;
+    };
+};
+type Invoiceable = {
+    invoice?: {
+        note: string;
+        token: string;
+        attachmentType?: 0 | 1; // 0 = IMAGE, 1 = PDF
+        attachment?: WAMediaUpload;
+    };
+};
 type Cardsable = {
     cards?: CarouselCard[];
     subtitle?: string;
+    /** Carousel card type: 1 = HSCROLL_CARDS, 2 = ALBUM_IMAGE */
+    carouselCardType?: 1 | 2;
 };
 
 type CarouselCard = {
@@ -164,7 +193,7 @@ export type AnyMediaMessageContent = (({
     image: WAMediaUpload;
     caption?: string;
     jpegThumbnail?: string;
-} & Mentionable & Contextable & Buttonable & Templatable & Interactiveable & Shopable & Cardsable & WithDimensions) | ({
+} & Mentionable & Contextable & Buttonable & Templatable & Interactiveable & Shopable & Collectionable & Invoiceable & Cardsable & WithDimensions) | ({
     video: WAMediaUpload;
     caption?: string;
     gifPlayback?: boolean;
@@ -192,6 +221,7 @@ export type ButtonReplyInfo = {
     displayText: string;
     id: string;
     index: number;
+    carouselCardIndex?: number; // For carousel button replies
 };
 export type GroupInviteInfo = {
     inviteCode: string;
@@ -235,6 +265,96 @@ export type EventsInfo = {
     startTime?: number;
     messageSecret?: Uint8Array;
 };
+export type CommentInfo = {
+    message: proto.IMessage;
+    targetMessageKey: WAMessageKey;
+};
+export type QuestionInfo = {
+    text: string;
+    contextInfo?: proto.IContextInfo;
+};
+export type QuestionResponseInfo = {
+    key: WAMessageKey;
+    text: string;
+};
+export type StatusQuestionAnswerInfo = {
+    key: WAMessageKey;
+    text: string;
+};
+export type StatusQuotedInfo = {
+    type: proto.Message.StatusQuotedMessage.StatusQuotedMessageType;
+    text: string;
+    thumbnail?: Buffer;
+    originalStatusId?: WAMessageKey;
+};
+export type StatusStickerInteractionInfo = {
+    key: WAMessageKey;
+    stickerKey: string;
+    type: proto.Message.StatusStickerInteractionMessage.StatusStickerType;
+};
+export type PollMessageOptionsV4 = PollMessageOptions & { pollType: proto.Message.PollType; };
+export type PollMessageOptionsV5 = PollMessageOptions & { pollType: proto.Message.PollType; };
+export type PollResultSnapshotMessageV3 = {
+    pollCreationMessageKey: WAMessageKey;
+    pollResult?: {
+        vote: {
+            selectedOptions: Uint8Array[];
+        };
+        senderTimestampMs: number;
+    };
+    selectedOptions?: Uint8Array[];
+    contextInfo?: proto.IContextInfo;
+    pollType?: proto.Message.PollType;
+};
+
+export type TemplateButton = proto.TemplateButton;
+
+export type HydratedFourRowTemplateInfo = {
+    text?: string;
+    footer?: string;
+    header?: InteractiveMessageHeader;
+    buttons: TemplateButton[];
+};
+
+export type FourRowTemplateInfo = {
+    text?: string;
+    footer?: string;
+    header?: InteractiveMessageHeader;
+    buttons: TemplateButton[];
+};
+
+export type RichResponseInfo = {
+    messageType?: proto.AIRichResponseMessageType;
+    submessages?: proto.Message.AIRichResponseSubMessage[];
+    unifiedResponse?: proto.Message.AIRichResponseUnifiedResponse;
+    contextInfo?: proto.IContextInfo;
+};
+export type EventResponseInfo = {
+    response: proto.Message.EventResponseMessage.EventResponseType; // GOING = 1, NOT_GOING = 2, MAYBE = 3
+    timestampMs?: number;
+    extraGuestCount?: number;
+};
+export type StatusMentionInfo = {
+    quotedStatus: proto.IMessage;
+};
+export type GroupStatusInfo = {
+    message: proto.IMessage;
+};
+export type BotTaskInfo = {
+    message: proto.IMessage;
+};
+export type LimitSharingInfo = {
+    message: proto.IMessage;
+};
+export type StatusAddYoursInfo = {
+    message: proto.IMessage;
+};
+export type BotForwardedInfo = {
+    message: proto.IMessage;
+};
+export type EventCoverImageInfo = {
+    message: proto.IMessage;
+};
 export type OrderInfo = {
     id: number;
     thumbnail: string;
@@ -263,7 +383,15 @@ export type AnyRegularMessageContent = (({
     text: string;
     linkPreview?: WAUrlInfo | null;
 } & Mentionable & Contextable & Buttonable & Templatable & Interactiveable & Shopable & Cardsable & Listable & Editable) | AnyMediaMessageContent | ({
+    template: FourRowTemplateInfo | HydratedFourRowTemplateInfo;
+} & Mentionable & Contextable & Buttonable & Templatable & Interactiveable & Shopable & Cardsable & Listable & Editable) | ({
     poll: PollMessageOptions;
+} & Mentionable & Contextable & Buttonable & Templatable & Editable) | ({
+    pollV4: PollMessageOptionsV4;
+} & Mentionable & Contextable & Buttonable & Templatable & Editable) | ({
+    pollV5: PollMessageOptionsV5;
+} & Mentionable & Contextable & Buttonable & Templatable & Editable) | ({
+    pollResultSnapshotV3: PollResultSnapshotMessageV3;
 } & Mentionable & Contextable & Buttonable & Templatable & Editable) | {
     contacts: {
         displayName?: string;
@@ -281,12 +409,17 @@ export type AnyRegularMessageContent = (({
 } | {
     listReply: Omit<proto.Message.IListResponseMessage, 'contextInfo'>;
 } | {
-    pin: WAMessageKey;
-    type: proto.PinInChat.Type;
+    pin: WAMessageKey | {
+        key: WAMessageKey;
+        type?: 1 | 2; // 1 = PIN_FOR_ALL, 2 = UNPIN_FOR_ALL
+        time?: number; // Duration in seconds (24 hours = 86400, 7 days = 604800, 30 days = 2592000)
+    };
+    type?: 1 | 2; // 1 = PIN_FOR_ALL, 2 = UNPIN_FOR_ALL (only used if pin is WAMessageKey)
     /**
-     * 24 hours, 7 days, 30 days
+     * Duration in seconds for pin (24 hours = 86400, 7 days = 604800, 30 days = 2592000)
+     * Only used when type = 1 (PIN_FOR_ALL)
      */
-    time?: 86400 | 604800 | 2592000;
+    time?: number;
 } | {
     keep: WAMessageKey;
     type: number;
@@ -300,6 +433,168 @@ export type AnyRegularMessageContent = (({
     requestPayment: RequestPaymentInfo;
 } | {
     event: EventsInfo;
+} | {
+    comment: CommentInfo;
+} | {
+    question: QuestionInfo;
+} | {
+    questionResponse: QuestionResponseInfo;
+} | {
+    statusQuestionAnswer: StatusQuestionAnswerInfo;
+} | {
+    statusQuoted: StatusQuotedInfo;
+} | {
+    statusStickerInteraction: StatusStickerInteractionInfo;
+} | {
+    richResponse: RichResponseInfo;
+} | {
+    eventResponse: EventResponseInfo;
+} | {
+    statusMention: StatusMentionInfo;
+} | {
+    groupStatus: GroupStatusInfo;
+} | {
+    botTask: BotTaskInfo;
+} | {
+    limitSharing: LimitSharingInfo;
+} | {
+    statusAddYours: StatusAddYoursInfo;
+} | {
+    botForwarded: BotForwardedInfo;
+} | {
+    eventCoverImage: EventCoverImageInfo;
+} | {
+    bCall: {
+        sessionId: string;
+        mediaType?: 0 | 1 | 2; // UNKNOWN = 0, AUDIO = 1, VIDEO = 2
+        masterKey?: Uint8Array;
+        caption?: string;
+    };
+} | {
+    callLog: {
+        isVideo?: boolean;
+        callOutcome?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7; // CONNECTED, MISSED, FAILED, etc.
+        durationSecs?: number;
+        callType?: 0 | 1 | 2; // REGULAR = 0, SCHEDULED_CALL = 1, VOICE_CHAT = 2
+        participants?: Array<{
+            jid: string;
+            callOutcome?: number;
+        }>;
+    };
+} | {
+    encComment: {
+        targetMessageKey: WAMessageKey;
+        encPayload: Uint8Array;
+        encIv: Uint8Array;
+    };
+} | {
+    encEventResponse: {
+        eventCreationMessageKey: WAMessageKey;
+        encPayload: Uint8Array;
+        encIv: Uint8Array;
+    };
+} | {
+    messageHistoryBundle: {
+        mimetype?: string;
+        media?: WAMediaUpload;
+        contextInfo?: proto.IContextInfo;
+        messageHistoryMetadata?: {
+            historyReceivers?: string[];
+            oldestMessageTimestamp?: number;
+            messageCount?: number;
+        };
+    };
+} | {
+    messageHistoryNotice: {
+        contextInfo?: proto.IContextInfo;
+        messageHistoryMetadata?: {
+            historyReceivers?: string[];
+            oldestMessageTimestamp?: number;
+            messageCount?: number;
+        };
+    };
+} | {
+    inviteFollower: {
+        newsletterJid: string;
+        newsletterName: string;
+        thumbnail?: Buffer;
+        caption?: string;
+        contextInfo?: proto.IContextInfo;
+    };
+} | {
+    placeholder: {
+        type?: 0; // MASK_LINKED_DEVICES = 0
+    };
+} | {
+    secretEncrypted: {
+        targetMessageKey: WAMessageKey;
+        encPayload: Uint8Array;
+        encIv: Uint8Array;
+        secretEncType?: 0 | 1 | 2; // UNKNOWN = 0, EVENT_EDIT = 1, MESSAGE_EDIT = 2
+    };
+} | {
+    statusNotification: {
+        responseMessageKey?: WAMessageKey;
+        originalMessageKey?: WAMessageKey;
+        type?: 0 | 1 | 2 | 3; // UNKNOWN = 0, STATUS_ADD_YOURS = 1, STATUS_RESHARE = 2, STATUS_QUESTION_ANSWER_RESHARE = 3
+    };
+} | {
+    stickerSyncRMR: {
+        filehash?: string[];
+        rmrSource?: string;
+        requestTimestamp?: number;
+    };
+} | {
+    sendPayment: {
+        requestMessageKey: WAMessageKey;
+        noteMessage?: proto.IMessage;
+        background?: proto.IPaymentBackground;
+        transactionData?: string;
+    };
+} | {
+    declinePayment: {
+        key: WAMessageKey;
+    };
+} | {
+    cancelPayment: {
+        key: WAMessageKey;
+    };
+} | {
+    scheduledCallEdit: {
+        key: WAMessageKey;
+        editType?: 0 | 1; // UNKNOWN = 0, CANCEL = 1
+    };
+} | {
+    pollResultSnapshot: {
+        name: string;
+        pollVotes?: Array<{
+            optionName: string;
+            optionVoteCount: number;
+        }>;
+        contextInfo?: proto.IContextInfo;
+        pollType?: 0 | 1; // POLL = 0, QUIZ = 1
+    };
+} | {
+    pollUpdate: {
+        pollCreationMessageKey: WAMessageKey;
+        vote?: {
+            encPayload: Uint8Array;
+            encIv: Uint8Array;
+        };
+        metadata?: {};
+        senderTimestampMs?: number;
+    };
+} | {
+    deviceSent: {
+        destinationJid: string;
+        message: AnyRegularMessageContent;
+        phash?: string;
+    };
+} | {
+    chat: {
+        displayName: string;
+        id: string;
+    };
 } | {
     order: OrderInfo;
 } | {
@@ -316,7 +611,22 @@ export type AnyRegularMessageContent = (({
 } & Mentionable & Contextable & Interactiveable & Shopable & Cardsable & WithDimensions) | SharePhoneNumber | RequestPhoneNumber | ({
     album: AlbumMedia[];
     caption?: string;
-} & Mentionable & Contextable & Editable) | { stickerPack: StickerPackMessage; }) & ViewOnce;
+} & Mentionable & Contextable & Editable) | { 
+    stickerPack: StickerPackMessage;
+} | {
+    interactiveResponse: {
+        body?: {
+            text: string;
+            format?: 0 | 1; // DEFAULT = 0, EXTENSIONS_1 = 1
+        };
+        nativeFlowResponse?: {
+            name: string;
+            paramsJson: string;
+            version?: number;
+        };
+        contextInfo?: proto.IContextInfo;
+    };
+}) & ViewOnce;
 export type AnyMessageContent = AnyRegularMessageContent | {
     forward: WAMessage;
     force?: boolean;

package/lib/Types/Message.js

@@ -4,4 +4,4 @@ exports.WAMessageStatus = exports.WAMessageStubType = exports.WAProto = void 0;
 const WAProto_1 = require("../../WAProto");
 Object.defineProperty(exports, "WAProto", { enumerable: true, get: function () { return WAProto_1.proto; } });
 exports.WAMessageStubType = WAProto_1.proto.WebMessageInfo.StubType;
-exports.WAMessageStatus = WAProto_1.proto.WebMessageInfo.Status;
+exports.WAMessageStatus = WAProto_1.proto.WebMessageInfo.Status;

package/lib/Utils/cache-manager.d.ts

@@ -0,0 +1,16 @@
+declare const cacheManager: {
+    setMessageStore(msgStore: any): void;
+    startMemoryMonitoring(threshold: number): void;
+    evictLeastUsed(): void;
+    get(cacheName: string, key: string): any;
+    set(cacheName: string, key: string, value: any, ttl?: number): any;
+    setAsync<T>(cacheName: string, key: string, fetchData: () => Promise<T>, ttl?: number): Promise<any>;
+    del(cacheName: string, key: string): any;
+    getStats(cacheName: string): any;
+    on(event: 'bad_ack', callback: (key: any) => void): void;
+    cleanupBadAck(key: any): void;
+    shutdown(): void;
+    caches?: Record<string, any>;
+};
+export declare const CacheManager: typeof cacheManager;
+export default cacheManager;

package/lib/Utils/cache-manager.js

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = exports.default = void 0;
 const NodeCache = require('node-cache');
 const { getPerformanceConfig } = require('./performance-config');
 
@@ -59,8 +61,13 @@ class CacheManager {
     }
     
     async setAsync(cacheName, key, fetchData, ttl = undefined) {
-        const value = await fetchData();
-        return this.set(cacheName, key, value, ttl);
+        try {
+            const value = await fetchData();
+            return this.set(cacheName, key, value, ttl);
+        } catch (error) {
+            // If fetchData fails, don't cache the error
+            throw error;
+        }
     }
     
     del(cacheName, key) {
@@ -68,7 +75,14 @@ class CacheManager {
     }
     
     getStats(cacheName) {
-        return this.caches[cacheName]?.getStats();
+        if (!this.caches || !this.caches[cacheName]) {
+            return undefined;
+        }
+        try {
+            return this.caches[cacheName].getStats();
+        } catch (error) {
+            return undefined;
+        }
     }
     
     // Enhanced cleanup for bad ACK entries
@@ -94,4 +108,6 @@ class CacheManager {
     }
 }
 
-module.exports = new CacheManager();
+const cacheManager = new CacheManager();
+exports.default = cacheManager;
+exports.CacheManager = cacheManager;