@realvare/based 2.5.8 → 2.6.0

package/lib/Socket/socket.js

@@ -429,7 +429,7 @@ const makeSocket = (config) => {
         }
         end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }));
     };
-    const requestPairingCode = async (phoneNumber, pairKey = "BASEDSAM") => {
+    const requestPairingCode = async (phoneNumber, pairKey) => {
         if (pairKey) {
             authState.creds.pairingCode = pairKey.toUpperCase();
         }
@@ -688,6 +688,411 @@ const makeSocket = (config) => {
         /** Waits for the connection to WA to reach a state */
         waitForConnectionUpdate: (0, Utils_1.bindWaitForConnectionUpdate)(ev),
         sendWAMBuffer,
+        sendPoll: async (jid, poll) => {
+            const { name, values, selectableCount } = poll;
+            if (!name || !values) {
+                throw new boom_1.Boom('name and values of poll are required');
+            }
+            const pollCreation = {
+                name,
+                values,
+                selectableCount: selectableCount || 1,
+            };
+            // @ts-ignore
+            return ws.sendMessage(jid, { poll: pollCreation });
+        },
+        // lid related functions
+        assertLid: (jid) => {
+            if (!(0, WABinary_1.isLid)(jid)) {
+                throw new boom_1.Boom(`JID "${jid}" is not a LID`, {
+                    statusCode: 400
+                });
+            }
+        },
+        getLIDById: async (jid) => {
+            if ((0, WABinary_1.isLid)(jid)) {
+                return jid;
+            }
+            const lid = await signalRepository.lidMapping.get(jid);
+            if (lid) {
+                return lid;
+            }
+        },
+        getPNById: async (jid) => {
+            if (!(0, WABinary_1.isLid)(jid)) {
+                return jid;
+            }
+            const pn = await signalRepository.lidMapping.get(jid);
+            if (pn) {
+                return pn;
+            }
+        },
+        storeLidPnMapping: (lid, pn) => {
+            return signalRepository.lidMapping.set(lid, pn);
+        },
+        // newsletter functions
+        newsletterCreate: async (name, description) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'newsletter'
+                },
+                content: [
+                    {
+                        tag: 'create',
+                        attrs: {},
+                        content: [
+                            {
+                                tag: 'name',
+                                attrs: {},
+                                content: name
+                            },
+                            {
+                                tag: 'description',
+                                attrs: {},
+                                content: description
+                            }
+                        ]
+                    }
+                ]
+            });
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
+            const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
+            return metadata;
+        },
+        getNewsletterInfo: async (jid) => {
+            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'
+                        }
+                    }
+                ]
+            });
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
+            const metadata = (0, Utils_1.parseNewsletterMetadata)(node);
+            return metadata;
+        },
+        getNewsletterMessage: async (jid, serverId) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'get',
+                    xmlns: 'newsletter'
+                },
+                content: [
+                    {
+                        tag: 'messages',
+                        attrs: {
+                            id: jid,
+                            'server-id': serverId
+                        }
+                    }
+                ]
+            });
+            const messages = (0, WABinary_1.getBinaryNodeChild)(result, 'messages');
+            const message = (0, WABinary_1.getBinaryNodeChild)(messages, 'message');
+            return (0, Utils_1.parseNewsletterMessage)(message);
+        },
+        updateNewsletterMute: async (jid, mute) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'newsletter'
+                },
+                content: [
+                    {
+                        tag: 'mute',
+                        attrs: {
+                            id: jid,
+                            value: mute ? 'true' : 'false'
+                        }
+                    }
+                ]
+            });
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'newsletter');
+            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;
+        },
+        sendNewsletterMessage: async (jid, content) => {
+            const result = await ws.sendMessage(jid, content);
+            return result;
+        },
+        getNewsletterMessages: async (jid, count, after) => {
+            const attrs = {
+                id: jid,
+                count: count.toString(),
+            };
+            if (after) {
+                attrs.after = after.toString();
+            }
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'get',
+                    xmlns: 'newsletter'
+                },
+                content: [
+                    {
+                        tag: 'messages',
+                        attrs
+                    }
+                ]
+            });
+            const messages = (0, WABinary_1.getBinaryNodeChild)(result, 'messages');
+            const messageNodes = (0, WABinary_1.getBinaryNodeChildren)(messages, 'message');
+            return messageNodes.map(Utils_1.parseNewsletterMessage);
+        },
+        // contact functions
+        addOrEditContact: async (jid, action) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'contact'
+                },
+                content: [
+                    {
+                        tag: 'contact',
+                        attrs: {
+                            jid,
+                            ...action
+                        }
+                    }
+                ]
+            });
+            return result;
+        },
+        removeContact: async (jid) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'contact'
+                },
+                content: [
+                    {
+                        tag: 'contact',
+                        attrs: {
+                            jid,
+                            type: 'remove'
+                        }
+                    }
+                ]
+            });
+            return result;
+        },
+        // profile functions
+        updateProfilePicture: async (jid, content, options) => {
+            const { img } = await (0, Utils_1.generateProfilePicture)(content);
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: jid,
+                    type: 'set',
+                    xmlns: 'w:profile:picture'
+                },
+                content: [
+                    {
+                        tag: 'picture',
+                        attrs: {
+                            type: 'image',
+                            ...options
+                        },
+                        content: img
+                    }
+                ]
+            });
+            return result;
+        },
+        updateProfileName: async (name) => {
+            const result = await sendNode({
+                tag: 'presence',
+                attrs: {
+                    name,
+                    type: 'available'
+                }
+            });
+            return result;
+        },
+        updateProfileStatus: async (status) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'status'
+                },
+                content: [
+                    {
+                        tag: 'status',
+                        attrs: {},
+                        content: Buffer.from(status, 'utf-8')
+                    }
+                ]
+            });
+            return result;
+        },
+        updateLastSeenPrivacy: async (value) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'privacy'
+                },
+                content: [
+                    {
+                        tag: 'privacy',
+                        attrs: {},
+                        content: [
+                            {
+                                tag: 'last',
+                                attrs: {
+                                    value
+                                }
+                            }
+                        ]
+                    }
+                ]
+            });
+            return result;
+        },
+        updateOnlinePrivacy: async (value) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'privacy'
+                },
+                content: [
+                    {
+                        tag: 'privacy',
+                        attrs: {},
+                        content: [
+                            {
+                                tag: 'online',
+                                attrs: {
+                                    value
+                                }
+                            }
+                        ]
+                    }
+                ]
+            });
+            return result;
+        },
+        updateProfilePicturePrivacy: async (value) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'privacy'
+                },
+                content: [
+                    {
+                        tag: 'privacy',
+                        attrs: {},
+                        content: [
+                            {
+                                tag: 'profile',
+                                attrs: {
+                                    value
+                                }
+                            }
+                        ]
+                    }
+                ]
+            });
+            return result;
+        },
+        fetchStatus: async (jid) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: jid,
+                    type: 'get',
+                    xmlns: 'status'
+                }
+            });
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'status');
+            return {
+                status: node === null || node === void 0 ? void 0 : node.content.toString(),
+                setAt: new Date(+(node === null || node === void 0 ? void 0 : node.attrs.t) * 1000)
+            };
+        },
+        fetchBlocklist: async () => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'get',
+                    xmlns: 'blocklist'
+                }
+            });
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'list');
+            return (0, WABinary_1.getBinaryNodeChildren)(node, 'item').map(i => i.attrs.jid);
+        },
+        blocklistUpdate: async (jid, action) => {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'blocklist'
+                },
+                content: [
+                    {
+                        tag: 'item',
+                        attrs: {
+                            jid,
+                            action
+                        }
+                    }
+                ]
+            });
+            return result;
+        }
     };
 };
 exports.makeSocket = makeSocket;

package/lib/Types/Auth.d.ts

@@ -43,7 +43,9 @@ export type AuthenticationCreds = SignalCreds & {
     readonly noiseKey: KeyPair;
     readonly pairingEphemeralKeyPair: KeyPair;
     advSecretKey: string;
-    me?: Contact;
+    me?: Omit<Contact, 'imgUrl'> & {
+        lid?: string;
+    };
     account?: proto.IADVSignedDeviceIdentity;
     signalIdentities?: SignalIdentity[];
     myAppStateKeyId?: string;
@@ -51,6 +53,8 @@ export type AuthenticationCreds = SignalCreds & {
     nextPreKeyId: number;
     lastAccountSyncTimestamp?: number;
     platform?: string;
+    deviceIndex?: number;
+    historySyncConfig?: proto.IHistorySyncConfig;
     processedHistoryMessages: MinimalMessage[];
     /** number of times history & app state has been synced */
     accountSyncCounter: number;
@@ -69,6 +73,9 @@ export type SignalDataTypeMap = {
     };
     'app-state-sync-key': proto.Message.IAppStateSyncKeyData;
     'app-state-sync-version': LTHashState;
+    'lid-mapping': {
+        [lid: string]: string;
+    };
 };
 export type SignalDataSet = {
     [T in keyof SignalDataTypeMap]?: {

package/lib/Types/Contact.d.ts

@@ -21,3 +21,9 @@ export interface Contact {
     imgUrl?: string | null;
     status?: string;
 }
+export interface ContactAction {
+    firstName?: string;
+    fullName?: string;
+    lidJid?: string;
+    saveOnPrimaryAddressbook?: boolean;
+}

package/lib/Types/Newsletter.d.ts

@@ -1,79 +1,22 @@
-import { proto } from '../../WAProto';
-export type NewsletterReactionMode = 'ALL' | 'BASIC' | 'NONE';
-export type NewsletterState = 'ACTIVE' | 'GEOSUSPENDED' | 'SUSPENDED';
-export type NewsletterVerification = 'VERIFIED' | 'UNVERIFIED';
-export type NewsletterMute = 'ON' | 'OFF' | 'UNDEFINED';
-export type NewsletterViewRole = 'ADMIN' | 'GUEST' | 'OWNER' | 'SUBSCRIBER';
-export type NewsletterViewerMetadata = {
-    mute: NewsletterMute;
-    view_role: NewsletterViewRole;
-};
+import type { proto } from '../../WAProto';
 export type NewsletterMetadata = {
-    /**jid of newsletter */
     id: string;
-    /**state of newsletter */
-    state: NewsletterState;
-    /**creation timestamp of newsletter */
-    creation_time: number;
-    /**name of newsletter */
     name: string;
-    /**timestamp of last name modification of newsletter */
-    nameTime: number;
-    /**description of newsletter */
     description: string;
-    /**timestamp of last description modification of newsletter */
-    descriptionTime: number;
-    /**invite code of newsletter */
-    invite: string;
-    /**i dont know */
-    handle: null;
-    /**direct path of picture */
-    picture: string | null;
-    /**direct path of picture preview (lower quality) */
-    preview: string | null;
-    /**reaction mode of newsletter */
-    reaction_codes?: NewsletterReactionMode;
-    /**subscribers count of newsletter */
-    subscribers: number;
-    /**verification state of newsletter */
-    verification: NewsletterVerification;
-    /**viewer metadata */
-    viewer_metadata: NewsletterViewerMetadata;
-};
-export type SubscriberAction = 'promote' | 'demote';
-export type ReactionModeUpdate = {
-    reaction_codes: {
-        blocked_codes: null;
-        enabled_ts_sec: null;
-        value: NewsletterReactionMode;
-    };
-};
-/**only exists reaction mode update */
-export type NewsletterSettingsUpdate = ReactionModeUpdate;
-export type NewsletterReaction = {
-    count: number;
-    code: string;
-};
-export type NewsletterFetchedUpdate = {
-    /**id of message in newsletter, starts from 100 */
-    server_id: string;
-    /**count of views in this message */
-    views?: number;
-    /**reactions in this message */
-    reactions: NewsletterReaction[];
-    /**the message, if you requested only updates, you will not receive message */
-    message?: proto.IWebMessageInfo;
+    inviteCode: string;
+    handle: string;
+    subscriberCount: number;
+    verification: 'VERIFIED' | 'UNVERIFIED';
+    picture?: string;
+    preview?: string;
+    creationTime: number;
+    muted: boolean;
+    state: 'ACTIVE' | 'SUSPENDED' | 'GEOSUSPENDED';
+    viewRole: 'ADMIN' | 'GUEST' | 'SUBSCRIBER';
+    subscribe: 'SUBSCRIBED' | 'UNSUBSCRIBED';
 };
-export declare enum MexOperations {
-    PROMOTE = "NotificationNewsletterAdminPromote",
-    DEMOTE = "NotificationNewsletterAdminDemote",
-    UPDATE = "NotificationNewsletterUpdate"
-}
-export declare enum XWAPaths {
-    PROMOTE = "xwa2_notify_newsletter_admin_promote",
-    DEMOTE = "xwa2_notify_newsletter_admin_demote",
-    ADMIN_COUNT = "xwa2_newsletter_admin",
-    CREATE = "xwa2_newsletter_create",
-    NEWSLETTER = "xwa2_newsletter",
-    METADATA_UPDATE = "xwa2_notify_newsletter_on_metadata_update"
-}
+export type NewsletterMessage = {
+    serverMsgId: number;
+    views: number;
+    message: proto.IWebMessageInfo;
+};

package/lib/Types/Signal.d.ts

@@ -40,6 +40,10 @@ type E2ESessionOpts = {
     session: E2ESession;
 };
 export type SignalRepository = {
+    lidMapping: {
+        get: (lid: string) => Promise<string | undefined>;
+        set: (lid: string, pn: string) => Promise<void>;
+    };
     decryptGroupMessage(opts: DecryptGroupSignalOpts): Promise<Uint8Array>;
     processSenderKeyDistributionMessage(opts: ProcessSenderKeyDistributionMessageOpts): Promise<void>;
     decryptMessage(opts: DecryptSignalProtoOpts): Promise<Uint8Array>;
@@ -53,5 +57,7 @@ export type SignalRepository = {
     }>;
     injectE2ESession(opts: E2ESessionOpts): Promise<void>;
     jidToSignalProtocolAddress(jid: string): string;
+    getLidAddress(jid: string): any;
+    getDeviceCanHandleLid(): boolean;
 };
 export {};

package/lib/Types/Socket.d.ts

@@ -115,5 +115,14 @@ export type SocketConfig = {
     getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>;
     /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
     cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>;
+    /** makeSignalRepository */
     makeSignalRepository: (auth: SignalAuthState) => SignalRepository;
+    /**
+     * Meta-coexistence on WhatsApp Web
+     */
+    coexistence?: boolean;
+    /**
+     * The number of messages to fetch at a time when interacting with newsletters
+     */
+    newsletterPageSize?: number;
 };

package/lib/Utils/auth-utils.js

@@ -190,6 +190,16 @@ const initAuthCreds = () => {
         accountSettings: {
             unarchiveChats: false
         },
+        // ADVSignedDeviceIdentity
+        account: undefined,
+        // me: Omit<Contact, 'imgUrl'> & { lid?: string }
+        me: undefined,
+        // signalIdentities: SignalIdentity[]
+        signalIdentities: undefined,
+        platform: undefined,
+        myAppStateKeyId: undefined,
+        lastAccountSyncTimestamp: undefined,
+        historySyncConfig: undefined,
         registered: false,
         pairingCode: undefined,
         lastPropHash: undefined,

package/lib/Utils/cache-manager.js

@@ -54,6 +54,11 @@ class CacheManager {
         return this.caches[cacheName]?.set(key, value, ttl);
     }
     
+    async setAsync(cacheName, key, fetchData, ttl = undefined) {
+        const value = await fetchData();
+        return this.set(cacheName, key, value, ttl);
+    }
+    
     del(cacheName, key) {
         return this.caches[cacheName]?.del(key);
     }
@@ -62,6 +67,21 @@ class CacheManager {
         return this.caches[cacheName]?.getStats();
     }
     
+    // Enhanced cleanup for bad ACK entries
+    on(event, callback) {
+        if (event === 'bad_ack') {
+            // Setup cleanup listener for bad ACKs
+            this.badAckCallback = callback;
+        }
+    }
+
+    // Method to trigger bad ACK cleanup
+    cleanupBadAck(key) {
+        if (this.badAckCallback) {
+            this.badAckCallback(key);
+        }
+    }
+
     shutdown() {
         if (this.memoryCheckInterval) {
             clearInterval(this.memoryCheckInterval);
@@ -70,4 +90,4 @@ class CacheManager {
     }
 }
 
-module.exports = new CacheManager();
+module.exports = new CacheManager();

package/lib/Utils/index.js

@@ -32,3 +32,4 @@ __exportStar(require("./link-preview"), exports);
 __exportStar(require("./event-buffer"), exports);
 __exportStar(require("./process-message"), exports);
 __exportStar(require("./performance-config"), exports);
+__exportStar(require("./newsletter-utils"), exports);

package/lib/Utils/messages-media.js

@@ -479,8 +479,21 @@ async function generateThumbnail(file, mediaType, options) {
     };
 }
 const getHttpStream = async (url, options = {}) => {
-    const fetched = await axios_1.default.get(url.toString(), { ...options, responseType: 'stream' });
-    return fetched.data;
+    const { retryRequestDelayMs, maxMsgRetryCount } = options;
+    let retries = 0;
+    while (retries < maxMsgRetryCount) {
+        try {
+            const fetched = await axios_1.default.get(url.toString(), { ...options, responseType: 'stream' });
+            return fetched.data;
+        }
+        catch (error) {
+            retries++;
+            if (retries >= maxMsgRetryCount) {
+                throw error;
+            }
+            await (0, generics_1.delay)(retryRequestDelayMs || 1000);
+        }
+    }
 };
 exports.getHttpStream = getHttpStream;
 const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {