whatsapp-web.js 1.24.0 → 1.26.0

package/src/Client.js

@@ -7,12 +7,15 @@ const moduleRaid = require('@pedroslopez/moduleraid/moduleraid');
 const Util = require('./util/Util');
 const InterfaceController = require('./util/InterfaceController');
 const { WhatsWebURL, DefaultOptions, Events, WAState } = require('./util/Constants');
-const { ExposeStore, LoadUtils } = require('./util/Injected');
+const { ExposeAuthStore } = require('./util/Injected/AuthStore/AuthStore');
+const { ExposeStore } = require('./util/Injected/Store');
+const { ExposeLegacyAuthStore } = require('./util/Injected/AuthStore/LegacyAuthStore');
+const { ExposeLegacyStore } = require('./util/Injected/LegacyStore');
+const { LoadUtils } = require('./util/Injected/Utils');
 const ChatFactory = require('./factories/ChatFactory');
 const ContactFactory = require('./factories/ContactFactory');
 const WebCacheFactory = require('./webCache/WebCacheFactory');
 const { ClientInfo, Message, MessageMedia, Contact, Location, Poll, PollVote, GroupNotification, Label, Call, Buttons, List, Reaction } = require('./structures');
-const LegacySessionAuth = require('./authStrategies/LegacySessionAuth');
 const NoAuth = require('./authStrategies/NoAuth');
 
 /**
@@ -63,37 +66,227 @@ class Client extends EventEmitter {
         this.options = Util.mergeDefault(DefaultOptions, options);
         
         if(!this.options.authStrategy) {
-            if(Object.prototype.hasOwnProperty.call(this.options, 'session')) {
-                process.emitWarning(
-                    'options.session is deprecated and will be removed in a future release due to incompatibility with multi-device. ' +
-                    'Use the LocalAuth authStrategy, don\'t pass in a session as an option, or suppress this warning by using the LegacySessionAuth strategy explicitly (see https://wwebjs.dev/guide/authentication.html#legacysessionauth-strategy).',
-                    'DeprecationWarning'
-                );
-
-                this.authStrategy = new LegacySessionAuth({
-                    session: this.options.session,
-                    restartOnAuthFail: this.options.restartOnAuthFail
-                });
-            } else {
-                this.authStrategy = new NoAuth();
-            }
+            this.authStrategy = new NoAuth();
         } else {
             this.authStrategy = this.options.authStrategy;
         }
 
         this.authStrategy.setup(this);
 
+        /**
+         * @type {puppeteer.Browser}
+         */
         this.pupBrowser = null;
+        /**
+         * @type {puppeteer.Page}
+         */
         this.pupPage = null;
 
+        this.currentIndexHtml = null;
+        this.lastLoggedOut = false;
+
         Util.setFfmpegPath(this.options.ffmpegPath);
     }
+    /**
+     * Injection logic
+     * Private function
+     * @property {boolean} reinject is this a reinject?
+     */
+    async inject(reinject = false) {
+        await this.pupPage.waitForFunction('window.Debug?.VERSION != undefined', {timeout: this.options.authTimeoutMs});
+
+        const version = await this.getWWebVersion();
+        const isCometOrAbove = parseInt(version.split('.')?.[1]) >= 3000;
+
+        if (isCometOrAbove) {
+            await this.pupPage.evaluate(ExposeAuthStore);
+        } else {
+            await this.pupPage.evaluate(ExposeLegacyAuthStore, moduleRaid.toString());
+        }
+
+        const needAuthentication = await this.pupPage.evaluate(async () => {
+            let state = window.AuthStore.AppState.state;
+
+            if (state === 'OPENING' || state === 'UNLAUNCHED' || state === 'PAIRING') {
+                // wait till state changes
+                await new Promise(r => {
+                    window.AuthStore.AppState.on('change:state', function waitTillInit(_AppState, state) {
+                        if (state !== 'OPENING' && state !== 'UNLAUNCHED' && state !== 'PAIRING') {
+                            window.AuthStore.AppState.off('change:state', waitTillInit);
+                            r();
+                        } 
+                    });
+                }); 
+            }
+            state = window.AuthStore.AppState.state;
+            return state == 'UNPAIRED' || state == 'UNPAIRED_IDLE';
+        });
+
+        if (needAuthentication) {
+            const { failed, failureEventPayload, restart } = await this.authStrategy.onAuthenticationNeeded();
+
+            if(failed) {
+                /**
+                 * Emitted when there has been an error while trying to restore an existing session
+                 * @event Client#auth_failure
+                 * @param {string} message
+                 */
+                this.emit(Events.AUTHENTICATION_FAILURE, failureEventPayload);
+                await this.destroy();
+                if (restart) {
+                    // session restore failed so try again but without session to force new authentication
+                    return this.initialize();
+                }
+                return;
+            }
+
+            // Register qr events
+            let qrRetries = 0;
+            const injected = await this.pupPage.evaluate(() => {
+                return typeof window.onQRChangedEvent !== 'undefined';
+            });
+            if (!injected) {
+                await this.pupPage.exposeFunction('onQRChangedEvent', async (qr) => {
+                    /**
+                    * Emitted when a QR code is received
+                    * @event Client#qr
+                    * @param {string} qr QR Code
+                    */
+                    this.emit(Events.QR_RECEIVED, qr);
+                    if (this.options.qrMaxRetries > 0) {
+                        qrRetries++;
+                        if (qrRetries > this.options.qrMaxRetries) {
+                            this.emit(Events.DISCONNECTED, 'Max qrcode retries reached');
+                            await this.destroy();
+                        }
+                    }
+                });
+            }
+
+
+            await this.pupPage.evaluate(async () => {
+                const registrationInfo = await window.AuthStore.RegistrationUtils.waSignalStore.getRegistrationInfo();
+                const noiseKeyPair = await window.AuthStore.RegistrationUtils.waNoiseInfo.get();
+                const staticKeyB64 = window.AuthStore.Base64Tools.encodeB64(noiseKeyPair.staticKeyPair.pubKey);
+                const identityKeyB64 = window.AuthStore.Base64Tools.encodeB64(registrationInfo.identityKeyPair.pubKey);
+                const advSecretKey = await window.AuthStore.RegistrationUtils.getADVSecretKey();
+                const platform =  window.AuthStore.RegistrationUtils.DEVICE_PLATFORM;
+                const getQR = (ref) => ref + ',' + staticKeyB64 + ',' + identityKeyB64 + ',' + advSecretKey + ',' + platform;
+                
+                window.onQRChangedEvent(getQR(window.AuthStore.Conn.ref)); // initial qr
+                window.AuthStore.Conn.on('change:ref', (_, ref) => { window.onQRChangedEvent(getQR(ref)); }); // future QR changes
+            });
+        }
+
+        if (!reinject) {
+            await this.pupPage.exposeFunction('onAuthAppStateChangedEvent', async (state) => {
+                if (state == 'UNPAIRED_IDLE') {
+                    // refresh qr code
+                    window.Store.Cmd.refreshQR();
+                }
+            });
+
+            await this.pupPage.exposeFunction('onAppStateHasSyncedEvent', async () => {
+                const authEventPayload = await this.authStrategy.getAuthEventPayload();
+                /**
+                 * Emitted when authentication is successful
+                 * @event Client#authenticated
+                 */
+                this.emit(Events.AUTHENTICATED, authEventPayload);
+
+                const injected = await this.pupPage.evaluate(async () => {
+                    return typeof window.Store !== 'undefined' && typeof window.WWebJS !== 'undefined';
+                });
+
+                if (!injected) {
+                    if (this.options.webVersionCache.type === 'local' && this.currentIndexHtml) {
+                        const { type: webCacheType, ...webCacheOptions } = this.options.webVersionCache;
+                        const webCache = WebCacheFactory.createWebCache(webCacheType, webCacheOptions);
+            
+                        await webCache.persist(this.currentIndexHtml, version);
+                    }
+
+                    if (isCometOrAbove) {
+                        await this.pupPage.evaluate(ExposeStore);
+                    } else {
+                        // make sure all modules are ready before injection
+                        // 2 second delay after authentication makes sense and does not need to be made dyanmic or removed
+                        await new Promise(r => setTimeout(r, 2000)); 
+                        await this.pupPage.evaluate(ExposeLegacyStore);
+                    }
+
+                    // Check window.Store Injection
+                    await this.pupPage.waitForFunction('window.Store != undefined');
+            
+                    /**
+                     * Current connection information
+                     * @type {ClientInfo}
+                     */
+                    this.info = new ClientInfo(this, await this.pupPage.evaluate(() => {
+                        return { ...window.Store.Conn.serialize(), wid: window.Store.User.getMeUser() };
+                    }));
+
+                    this.interface = new InterfaceController(this);
+
+                    //Load util functions (serializers, helper functions)
+                    await this.pupPage.evaluate(LoadUtils);
+
+                    await this.attachEventListeners(reinject);
+                    reinject = true;
+                }
+                /**
+                 * Emitted when the client has initialized and is ready to receive messages.
+                 * @event Client#ready
+                 */
+                this.emit(Events.READY);
+                this.authStrategy.afterAuthReady();
+            });
+            let lastPercent = null;
+            await this.pupPage.exposeFunction('onOfflineProgressUpdateEvent', async (percent) => {
+                if (lastPercent !== percent) {
+                    lastPercent = percent;
+                    this.emit(Events.LOADING_SCREEN, percent, 'WhatsApp'); // Message is hardcoded as "WhatsApp" for now
+                }
+            });
+        }
+        const logoutCatchInjected = await this.pupPage.evaluate(() => {
+            return typeof window.onLogoutEvent !== 'undefined';
+        });
+        if (!logoutCatchInjected) {
+            await this.pupPage.exposeFunction('onLogoutEvent', async () => {
+                this.lastLoggedOut = true;
+                await this.pupPage.waitForNavigation({waitUntil: 'load', timeout: 5000}).catch((_) => _);
+            });
+        }
+        await this.pupPage.evaluate(() => {
+            window.AuthStore.AppState.on('change:state', (_AppState, state) => { window.onAuthAppStateChangedEvent(state); });
+            window.AuthStore.AppState.on('change:hasSynced', () => { window.onAppStateHasSyncedEvent(); });
+            window.AuthStore.Cmd.on('offline_progress_update', () => {
+                window.onOfflineProgressUpdateEvent(window.AuthStore.OfflineMessageHandler.getOfflineDeliveryProgress()); 
+            });
+            window.AuthStore.Cmd.on('logout', async () => {
+                await window.onLogoutEvent();
+            });
+        });
+    }
 
     /**
      * Sets up events and requirements, kicks off authentication request
      */
     async initialize() {
-        let [browser, page] = [null, null];
+
+        let 
+            /**
+             * @type {puppeteer.Browser}
+             */
+            browser, 
+            /**
+             * @type {puppeteer.Page}
+             */
+            page;
+
+        browser = null;
+        page = null;
 
         await this.authStrategy.beforeBrowserInitialized();
 
@@ -126,9 +319,11 @@ class Client extends EventEmitter {
         await this.authStrategy.afterBrowserInitialized();
         await this.initWebVersionCache();
 
-        // ocVesion (isOfficialClient patch)
+        // ocVersion (isOfficialClient patch)
+        // remove after 2.3000.x hard release
         await page.evaluateOnNewDocument(() => {
             const originalError = Error;
+            window.originalError = originalError;
             //eslint-disable-next-line no-global-assign
             Error = function (message) {
                 const error = new originalError(message);
@@ -144,549 +339,355 @@ class Client extends EventEmitter {
             referer: 'https://whatsapp.com/'
         });
 
-        await page.evaluate(`function getElementByXpath(path) {
-            return document.evaluate(path, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-          }`);
+        await this.inject();
 
-        let lastPercent = null,
-            lastPercentMessage = null;
-
-        await page.exposeFunction('loadingScreen', async (percent, message) => {
-            if (lastPercent !== percent || lastPercentMessage !== message) {
-                this.emit(Events.LOADING_SCREEN, percent, message);
-                lastPercent = percent;
-                lastPercentMessage = message;
+        this.pupPage.on('framenavigated', async (frame) => {
+            if(frame.url().includes('post_logout=1') || this.lastLoggedOut) {
+                this.emit(Events.DISCONNECTED, 'LOGOUT');
+                await this.authStrategy.logout();
+                await this.authStrategy.beforeBrowserInitialized();
+                await this.authStrategy.afterBrowserInitialized();
+                this.lastLoggedOut = false;
             }
+            await this.inject(true);
         });
+    }
 
-        await page.evaluate(
-            async function (selectors) {
-                var observer = new MutationObserver(function () {
-                    let progressBar = window.getElementByXpath(
-                        selectors.PROGRESS
-                    );
-                    let progressMessage = window.getElementByXpath(
-                        selectors.PROGRESS_MESSAGE
-                    );
+    /**
+     * Request authentication via pairing code instead of QR code
+     * @param {string} phoneNumber - Phone number in international, symbol-free format (e.g. 12025550108 for US, 551155501234 for Brazil)
+     * @param {boolean} showNotification - Show notification to pair on phone number
+     * @returns {Promise<string>} - Returns a pairing code in format "ABCDEFGH"
+     */
+    async requestPairingCode(phoneNumber, showNotification = true) {
+        return await this.pupPage.evaluate(async (phoneNumber, showNotification) => {
+            window.AuthStore.PairingCodeLinkUtils.setPairingType('ALT_DEVICE_LINKING');
+            await window.AuthStore.PairingCodeLinkUtils.initializeAltDeviceLinking();
+            return window.AuthStore.PairingCodeLinkUtils.startAltLinkingFlow(phoneNumber, showNotification);
+        }, phoneNumber, showNotification);
+    }
 
-                    if (progressBar) {
-                        window.loadingScreen(
-                            progressBar.value,
-                            progressMessage.innerText
-                        );
+    /**
+     * Attach event listeners to WA Web
+     * Private function
+     * @property {boolean} reinject is this a reinject?
+     */
+    async attachEventListeners(reinject = false) {
+        if (!reinject) {
+            await this.pupPage.exposeFunction('onAddMessageEvent', msg => {
+                if (msg.type === 'gp2') {
+                    const notification = new GroupNotification(this, msg);
+                    if (['add', 'invite', 'linked_group_join'].includes(msg.subtype)) {
+                        /**
+                         * Emitted when a user joins the chat via invite link or is added by an admin.
+                         * @event Client#group_join
+                         * @param {GroupNotification} notification GroupNotification with more information about the action
+                         */
+                        this.emit(Events.GROUP_JOIN, notification);
+                    } else if (msg.subtype === 'remove' || msg.subtype === 'leave') {
+                        /**
+                         * Emitted when a user leaves the chat or is removed by an admin.
+                         * @event Client#group_leave
+                         * @param {GroupNotification} notification GroupNotification with more information about the action
+                         */
+                        this.emit(Events.GROUP_LEAVE, notification);
+                    } else if (msg.subtype === 'promote' || msg.subtype === 'demote') {
+                        /**
+                         * Emitted when a current user is promoted to an admin or demoted to a regular user.
+                         * @event Client#group_admin_changed
+                         * @param {GroupNotification} notification GroupNotification with more information about the action
+                         */
+                        this.emit(Events.GROUP_ADMIN_CHANGED, notification);
+                    } else if (msg.subtype === 'membership_approval_request') {
+                        /**
+                         * Emitted when some user requested to join the group
+                         * that has the membership approval mode turned on
+                         * @event Client#group_membership_request
+                         * @param {GroupNotification} notification GroupNotification with more information about the action
+                         * @param {string} notification.chatId The group ID the request was made for
+                         * @param {string} notification.author The user ID that made a request
+                         * @param {number} notification.timestamp The timestamp the request was made at
+                         */
+                        this.emit(Events.GROUP_MEMBERSHIP_REQUEST, notification);
+                    } else {
+                        /**
+                         * Emitted when group settings are updated, such as subject, description or picture.
+                         * @event Client#group_update
+                         * @param {GroupNotification} notification GroupNotification with more information about the action
+                         */
+                        this.emit(Events.GROUP_UPDATE, notification);
                     }
-                });
-
-                observer.observe(document, {
-                    attributes: true,
-                    childList: true,
-                    characterData: true,
-                    subtree: true,
-                });
-            },
-            {
-                PROGRESS: '//*[@id=\'app\']/div/div/div[2]/progress',
-                PROGRESS_MESSAGE: '//*[@id=\'app\']/div/div/div[3]',
-            }
-        );
-
-        const INTRO_IMG_SELECTOR = '[data-icon=\'search\']';
-        const INTRO_QRCODE_SELECTOR = 'div[data-ref] canvas';
-
-        // Checks which selector appears first
-        const needAuthentication = await Promise.race([
-            new Promise(resolve => {
-                page.waitForSelector(INTRO_IMG_SELECTOR, { timeout: this.options.authTimeoutMs })
-                    .then(() => resolve(false))
-                    .catch((err) => resolve(err));
-            }),
-            new Promise(resolve => {
-                page.waitForSelector(INTRO_QRCODE_SELECTOR, { timeout: this.options.authTimeoutMs })
-                    .then(() => resolve(true))
-                    .catch((err) => resolve(err));
-            })
-        ]);
-
-        // Checks if an error occurred on the first found selector. The second will be discarded and ignored by .race;
-        if (needAuthentication instanceof Error) throw needAuthentication;
-
-        // Scan-qrcode selector was found. Needs authentication
-        if (needAuthentication) {
-            const { failed, failureEventPayload, restart } = await this.authStrategy.onAuthenticationNeeded();
-            if(failed) {
-                /**
-                 * Emitted when there has been an error while trying to restore an existing session
-                 * @event Client#auth_failure
-                 * @param {string} message
-                 */
-                this.emit(Events.AUTHENTICATION_FAILURE, failureEventPayload);
-                await this.destroy();
-                if (restart) {
-                    // session restore failed so try again but without session to force new authentication
-                    return this.initialize();
+                    return;
                 }
-                return;
-            }
 
-            const QR_CONTAINER = 'div[data-ref]';
-            const QR_RETRY_BUTTON = 'div[data-ref] > span > button';
-            let qrRetries = 0;
-            await page.exposeFunction('qrChanged', async (qr) => {
+                const message = new Message(this, msg);
+
                 /**
-                * Emitted when a QR code is received
-                * @event Client#qr
-                * @param {string} qr QR Code
-                */
-                this.emit(Events.QR_RECEIVED, qr);
-                if (this.options.qrMaxRetries > 0) {
-                    qrRetries++;
-                    if (qrRetries > this.options.qrMaxRetries) {
-                        this.emit(Events.DISCONNECTED, 'Max qrcode retries reached');
-                        await this.destroy();
-                    }
-                }
-            });
+                 * Emitted when a new message is created, which may include the current user's own messages.
+                 * @event Client#message_create
+                 * @param {Message} message The message that was created
+                 */
+                this.emit(Events.MESSAGE_CREATE, message);
 
-            await page.evaluate(function (selectors) {
-                const qr_container = document.querySelector(selectors.QR_CONTAINER);
-                window.qrChanged(qr_container.dataset.ref);
+                if (msg.id.fromMe) return;
 
-                const obs = new MutationObserver((muts) => {
-                    muts.forEach(mut => {
-                        // Listens to qr token change
-                        if (mut.type === 'attributes' && mut.attributeName === 'data-ref') {
-                            window.qrChanged(mut.target.dataset.ref);
-                        }
-                        // Listens to retry button, when found, click it
-                        else if (mut.type === 'childList') {
-                            const retry_button = document.querySelector(selectors.QR_RETRY_BUTTON);
-                            if (retry_button) retry_button.click();
-                        }
-                    });
-                });
-                obs.observe(qr_container.parentElement, {
-                    subtree: true,
-                    childList: true,
-                    attributes: true,
-                    attributeFilter: ['data-ref'],
-                });
-            }, {
-                QR_CONTAINER,
-                QR_RETRY_BUTTON
+                /**
+                 * Emitted when a new message is received.
+                 * @event Client#message
+                 * @param {Message} message The message that was received
+                 */
+                this.emit(Events.MESSAGE_RECEIVED, message);
             });
 
-            // Wait for code scan
-            try {
-                await page.waitForSelector(INTRO_IMG_SELECTOR, { timeout: 0 });
-            } catch(error) {
-                if (
-                    error.name === 'ProtocolError' && 
-                    error.message && 
-                    error.message.match(/Target closed/)
-                ) {
-                    // something has called .destroy() while waiting
-                    return;
-                }
-
-                throw error;
-            }
-
-        }
-
-        await page.evaluate(() => {
-            /**
-             * Helper function that compares between two WWeb versions. Its purpose is to help the developer to choose the correct code implementation depending on the comparison value and the WWeb version.
-             * @param {string} lOperand The left operand for the WWeb version string to compare with
-             * @param {string} operator The comparison operator
-             * @param {string} rOperand The right operand for the WWeb version string to compare with
-             * @returns {boolean} Boolean value that indicates the result of the comparison
-             */
-            window.compareWwebVersions = (lOperand, operator, rOperand) => {
-                if (!['>', '>=', '<', '<=', '='].includes(operator)) {
-                    throw new class _ extends Error {
-                        constructor(m) { super(m); this.name = 'CompareWwebVersionsError'; }
-                    }('Invalid comparison operator is provided');
+            let last_message;
 
-                }
-                if (typeof lOperand !== 'string' || typeof rOperand !== 'string') {
-                    throw new class _ extends Error {
-                        constructor(m) { super(m); this.name = 'CompareWwebVersionsError'; }
-                    }('A non-string WWeb version type is provided');
-                }
+            await this.pupPage.exposeFunction('onChangeMessageTypeEvent', (msg) => {
 
-                lOperand = lOperand.replace(/-beta$/, '');
-                rOperand = rOperand.replace(/-beta$/, '');
+                if (msg.type === 'revoked') {
+                    const message = new Message(this, msg);
+                    let revoked_msg;
+                    if (last_message && msg.id.id === last_message.id.id) {
+                        revoked_msg = new Message(this, last_message);
+                    }
 
-                while (lOperand.length !== rOperand.length) {
-                    lOperand.length > rOperand.length
-                        ? rOperand = rOperand.concat('0')
-                        : lOperand = lOperand.concat('0');
+                    /**
+                     * Emitted when a message is deleted for everyone in the chat.
+                     * @event Client#message_revoke_everyone
+                     * @param {Message} message The message that was revoked, in its current state. It will not contain the original message's data.
+                     * @param {?Message} revoked_msg The message that was revoked, before it was revoked. It will contain the message's original data. 
+                     * Note that due to the way this data is captured, it may be possible that this param will be undefined.
+                     */
+                    this.emit(Events.MESSAGE_REVOKED_EVERYONE, message, revoked_msg);
                 }
 
-                lOperand = Number(lOperand.replace(/\./g, ''));
-                rOperand = Number(rOperand.replace(/\./g, ''));
+            });
 
-                return (
-                    operator === '>' ? lOperand > rOperand :
-                        operator === '>=' ? lOperand >= rOperand :
-                            operator === '<' ? lOperand < rOperand :
-                                operator === '<=' ? lOperand <= rOperand :
-                                    operator === '=' ? lOperand === rOperand :
-                                        false
-                );
-            };
-        });
+            await this.pupPage.exposeFunction('onChangeMessageEvent', (msg) => {
 
-        await page.evaluate(ExposeStore, moduleRaid.toString());
-        const authEventPayload = await this.authStrategy.getAuthEventPayload();
+                if (msg.type !== 'revoked') {
+                    last_message = msg;
+                }
 
-        /**
-         * Emitted when authentication is successful
-         * @event Client#authenticated
-         */
-        this.emit(Events.AUTHENTICATED, authEventPayload);
+                /**
+                 * The event notification that is received when one of
+                 * the group participants changes their phone number.
+                 */
+                const isParticipant = msg.type === 'gp2' && msg.subtype === 'modify';
 
-        // Check window.Store Injection
-        await page.waitForFunction('window.Store != undefined');
+                /**
+                 * The event notification that is received when one of
+                 * the contacts changes their phone number.
+                 */
+                const isContact = msg.type === 'notification_template' && msg.subtype === 'change_number';
 
-        await page.evaluate(async () => {
-            // safely unregister service workers
-            const registrations = await navigator.serviceWorker.getRegistrations();
-            for (let registration of registrations) {
-                registration.unregister();
-            }
-        });
+                if (isParticipant || isContact) {
+                    /** @type {GroupNotification} object does not provide enough information about this event, so a @type {Message} object is used. */
+                    const message = new Message(this, msg);
 
-        //Load util functions (serializers, helper functions)
-        await page.evaluate(LoadUtils);
+                    const newId = isParticipant ? msg.recipients[0] : msg.to;
+                    const oldId = isParticipant ? msg.author : msg.templateParams.find(id => id !== newId);
 
-        // Expose client info
-        /**
-         * Current connection information
-         * @type {ClientInfo}
-         */
-        this.info = new ClientInfo(this, await page.evaluate(() => {
-            return { ...window.Store.Conn.serialize(), wid: window.Store.User.getMeUser() };
-        }));
-
-        // Add InterfaceController
-        this.interface = new InterfaceController(this);
-
-        // Register events
-        await page.exposeFunction('onAddMessageEvent', msg => {
-            if (msg.type === 'gp2') {
-                const notification = new GroupNotification(this, msg);
-                if (['add', 'invite', 'linked_group_join'].includes(msg.subtype)) {
-                    /**
-                     * Emitted when a user joins the chat via invite link or is added by an admin.
-                     * @event Client#group_join
-                     * @param {GroupNotification} notification GroupNotification with more information about the action
-                     */
-                    this.emit(Events.GROUP_JOIN, notification);
-                } else if (msg.subtype === 'remove' || msg.subtype === 'leave') {
-                    /**
-                     * Emitted when a user leaves the chat or is removed by an admin.
-                     * @event Client#group_leave
-                     * @param {GroupNotification} notification GroupNotification with more information about the action
-                     */
-                    this.emit(Events.GROUP_LEAVE, notification);
-                } else if (msg.subtype === 'promote' || msg.subtype === 'demote') {
-                    /**
-                     * Emitted when a current user is promoted to an admin or demoted to a regular user.
-                     * @event Client#group_admin_changed
-                     * @param {GroupNotification} notification GroupNotification with more information about the action
-                     */
-                    this.emit(Events.GROUP_ADMIN_CHANGED, notification);
-                } else if (msg.subtype === 'membership_approval_request') {
-                    /**
-                     * Emitted when some user requested to join the group
-                     * that has the membership approval mode turned on
-                     * @event Client#group_membership_request
-                     * @param {GroupNotification} notification GroupNotification with more information about the action
-                     * @param {string} notification.chatId The group ID the request was made for
-                     * @param {string} notification.author The user ID that made a request
-                     * @param {number} notification.timestamp The timestamp the request was made at
-                     */
-                    this.emit(Events.GROUP_MEMBERSHIP_REQUEST, notification);
-                } else {
                     /**
-                     * Emitted when group settings are updated, such as subject, description or picture.
-                     * @event Client#group_update
-                     * @param {GroupNotification} notification GroupNotification with more information about the action
+                     * Emitted when a contact or a group participant changes their phone number.
+                     * @event Client#contact_changed
+                     * @param {Message} message Message with more information about the event.
+                     * @param {String} oldId The user's id (an old one) who changed their phone number
+                     * and who triggered the notification.
+                     * @param {String} newId The user's new id after the change.
+                     * @param {Boolean} isContact Indicates if a contact or a group participant changed their phone number.
                      */
-                    this.emit(Events.GROUP_UPDATE, notification);
+                    this.emit(Events.CONTACT_CHANGED, message, oldId, newId, isContact);
                 }
-                return;
-            }
-
-            const message = new Message(this, msg);
-
-            /**
-             * Emitted when a new message is created, which may include the current user's own messages.
-             * @event Client#message_create
-             * @param {Message} message The message that was created
-             */
-            this.emit(Events.MESSAGE_CREATE, message);
-
-            if (msg.id.fromMe) return;
-
-            /**
-             * Emitted when a new message is received.
-             * @event Client#message
-             * @param {Message} message The message that was received
-             */
-            this.emit(Events.MESSAGE_RECEIVED, message);
-        });
+            });
 
-        let last_message;
+            await this.pupPage.exposeFunction('onRemoveMessageEvent', (msg) => {
 
-        await page.exposeFunction('onChangeMessageTypeEvent', (msg) => {
+                if (!msg.isNewMsg) return;
 
-            if (msg.type === 'revoked') {
                 const message = new Message(this, msg);
-                let revoked_msg;
-                if (last_message && msg.id.id === last_message.id.id) {
-                    revoked_msg = new Message(this, last_message);
-                }
 
                 /**
-                 * Emitted when a message is deleted for everyone in the chat.
-                 * @event Client#message_revoke_everyone
-                 * @param {Message} message The message that was revoked, in its current state. It will not contain the original message's data.
-                 * @param {?Message} revoked_msg The message that was revoked, before it was revoked. It will contain the message's original data. 
-                 * Note that due to the way this data is captured, it may be possible that this param will be undefined.
+                 * Emitted when a message is deleted by the current user.
+                 * @event Client#message_revoke_me
+                 * @param {Message} message The message that was revoked
                  */
-                this.emit(Events.MESSAGE_REVOKED_EVERYONE, message, revoked_msg);
-            }
+                this.emit(Events.MESSAGE_REVOKED_ME, message);
 
-        });
-
-        await page.exposeFunction('onChangeMessageEvent', (msg) => {
-
-            if (msg.type !== 'revoked') {
-                last_message = msg;
-            }
-
-            /**
-             * The event notification that is received when one of
-             * the group participants changes their phone number.
-             */
-            const isParticipant = msg.type === 'gp2' && msg.subtype === 'modify';
+            });
 
-            /**
-             * The event notification that is received when one of
-             * the contacts changes their phone number.
-             */
-            const isContact = msg.type === 'notification_template' && msg.subtype === 'change_number';
+            await this.pupPage.exposeFunction('onMessageAckEvent', (msg, ack) => {
 
-            if (isParticipant || isContact) {
-                /** @type {GroupNotification} object does not provide enough information about this event, so a @type {Message} object is used. */
                 const message = new Message(this, msg);
 
-                const newId = isParticipant ? msg.recipients[0] : msg.to;
-                const oldId = isParticipant ? msg.author : msg.templateParams.find(id => id !== newId);
-
                 /**
-                 * Emitted when a contact or a group participant changes their phone number.
-                 * @event Client#contact_changed
-                 * @param {Message} message Message with more information about the event.
-                 * @param {String} oldId The user's id (an old one) who changed their phone number
-                 * and who triggered the notification.
-                 * @param {String} newId The user's new id after the change.
-                 * @param {Boolean} isContact Indicates if a contact or a group participant changed their phone number.
+                 * Emitted when an ack event occurrs on message type.
+                 * @event Client#message_ack
+                 * @param {Message} message The message that was affected
+                 * @param {MessageAck} ack The new ACK value
                  */
-                this.emit(Events.CONTACT_CHANGED, message, oldId, newId, isContact);
-            }
-        });
-
-        await page.exposeFunction('onRemoveMessageEvent', (msg) => {
-
-            if (!msg.isNewMsg) return;
-
-            const message = new Message(this, msg);
-
-            /**
-             * Emitted when a message is deleted by the current user.
-             * @event Client#message_revoke_me
-             * @param {Message} message The message that was revoked
-             */
-            this.emit(Events.MESSAGE_REVOKED_ME, message);
-
-        });
-
-        await page.exposeFunction('onMessageAckEvent', (msg, ack) => {
+                this.emit(Events.MESSAGE_ACK, message, ack);
 
-            const message = new Message(this, msg);
+            });
 
-            /**
-             * Emitted when an ack event occurrs on message type.
-             * @event Client#message_ack
-             * @param {Message} message The message that was affected
-             * @param {MessageAck} ack The new ACK value
-             */
-            this.emit(Events.MESSAGE_ACK, message, ack);
+            await this.pupPage.exposeFunction('onChatUnreadCountEvent', async (data) =>{
+                const chat = await this.getChatById(data.id);
+                
+                /**
+                 * Emitted when the chat unread count changes
+                 */
+                this.emit(Events.UNREAD_COUNT, chat);
+            });
 
-        });
+            await this.pupPage.exposeFunction('onMessageMediaUploadedEvent', (msg) => {
 
-        await page.exposeFunction('onChatUnreadCountEvent', async (data) =>{
-            const chat = await this.getChatById(data.id);
-            
-            /**
-             * Emitted when the chat unread count changes
-             */
-            this.emit(Events.UNREAD_COUNT, chat);
-        });
+                const message = new Message(this, msg);
 
-        await page.exposeFunction('onMessageMediaUploadedEvent', (msg) => {
+                /**
+                 * Emitted when media has been uploaded for a message sent by the client.
+                 * @event Client#media_uploaded
+                 * @param {Message} message The message with media that was uploaded
+                 */
+                this.emit(Events.MEDIA_UPLOADED, message);
+            });
 
-            const message = new Message(this, msg);
+            await this.pupPage.exposeFunction('onAppStateChangedEvent', async (state) => {
+                /**
+                 * Emitted when the connection state changes
+                 * @event Client#change_state
+                 * @param {WAState} state the new connection state
+                 */
+                this.emit(Events.STATE_CHANGED, state);
 
-            /**
-             * Emitted when media has been uploaded for a message sent by the client.
-             * @event Client#media_uploaded
-             * @param {Message} message The message with media that was uploaded
-             */
-            this.emit(Events.MEDIA_UPLOADED, message);
-        });
+                const ACCEPTED_STATES = [WAState.CONNECTED, WAState.OPENING, WAState.PAIRING, WAState.TIMEOUT];
 
-        await page.exposeFunction('onAppStateChangedEvent', async (state) => {
+                if (this.options.takeoverOnConflict) {
+                    ACCEPTED_STATES.push(WAState.CONFLICT);
 
-            /**
-             * Emitted when the connection state changes
-             * @event Client#change_state
-             * @param {WAState} state the new connection state
-             */
-            this.emit(Events.STATE_CHANGED, state);
+                    if (state === WAState.CONFLICT) {
+                        setTimeout(() => {
+                            this.pupPage.evaluate(() => window.Store.AppState.takeover());
+                        }, this.options.takeoverTimeoutMs);
+                    }
+                }
 
-            const ACCEPTED_STATES = [WAState.CONNECTED, WAState.OPENING, WAState.PAIRING, WAState.TIMEOUT];
+                if (!ACCEPTED_STATES.includes(state)) {
+                    /**
+                     * Emitted when the client has been disconnected
+                     * @event Client#disconnected
+                     * @param {WAState|"LOGOUT"} reason reason that caused the disconnect
+                     */
+                    await this.authStrategy.disconnect();
+                    this.emit(Events.DISCONNECTED, state);
+                    this.destroy();
+                }
+            });
 
-            if (this.options.takeoverOnConflict) {
-                ACCEPTED_STATES.push(WAState.CONFLICT);
+            await this.pupPage.exposeFunction('onBatteryStateChangedEvent', (state) => {
+                const { battery, plugged } = state;
 
-                if (state === WAState.CONFLICT) {
-                    setTimeout(() => {
-                        this.pupPage.evaluate(() => window.Store.AppState.takeover());
-                    }, this.options.takeoverTimeoutMs);
-                }
-            }
+                if (battery === undefined) return;
 
-            if (!ACCEPTED_STATES.includes(state)) {
                 /**
-                 * Emitted when the client has been disconnected
-                 * @event Client#disconnected
-                 * @param {WAState|"NAVIGATION"} reason reason that caused the disconnect
+                 * Emitted when the battery percentage for the attached device changes. Will not be sent if using multi-device.
+                 * @event Client#change_battery
+                 * @param {object} batteryInfo
+                 * @param {number} batteryInfo.battery - The current battery percentage
+                 * @param {boolean} batteryInfo.plugged - Indicates if the phone is plugged in (true) or not (false)
+                 * @deprecated
                  */
-                await this.authStrategy.disconnect();
-                this.emit(Events.DISCONNECTED, state);
-                this.destroy();
-            }
-        });
+                this.emit(Events.BATTERY_CHANGED, { battery, plugged });
+            });
 
-        await page.exposeFunction('onBatteryStateChangedEvent', (state) => {
-            const { battery, plugged } = state;
+            await this.pupPage.exposeFunction('onIncomingCall', (call) => {
+                /**
+                 * Emitted when a call is received
+                 * @event Client#incoming_call
+                 * @param {object} call
+                 * @param {number} call.id - Call id
+                 * @param {string} call.peerJid - Who called
+                 * @param {boolean} call.isVideo - if is video
+                 * @param {boolean} call.isGroup - if is group
+                 * @param {boolean} call.canHandleLocally - if we can handle in waweb
+                 * @param {boolean} call.outgoing - if is outgoing
+                 * @param {boolean} call.webClientShouldHandle - If Waweb should handle
+                 * @param {object} call.participants - Participants
+                 */
+                const cll = new Call(this, call);
+                this.emit(Events.INCOMING_CALL, cll);
+            });
 
-            if (battery === undefined) return;
+            await this.pupPage.exposeFunction('onReaction', (reactions) => {
+                for (const reaction of reactions) {
+                    /**
+                     * Emitted when a reaction is sent, received, updated or removed
+                     * @event Client#message_reaction
+                     * @param {object} reaction
+                     * @param {object} reaction.id - Reaction id
+                     * @param {number} reaction.orphan - Orphan
+                     * @param {?string} reaction.orphanReason - Orphan reason
+                     * @param {number} reaction.timestamp - Timestamp
+                     * @param {string} reaction.reaction - Reaction
+                     * @param {boolean} reaction.read - Read
+                     * @param {object} reaction.msgId - Parent message id
+                     * @param {string} reaction.senderId - Sender id
+                     * @param {?number} reaction.ack - Ack
+                     */
 
-            /**
-             * Emitted when the battery percentage for the attached device changes. Will not be sent if using multi-device.
-             * @event Client#change_battery
-             * @param {object} batteryInfo
-             * @param {number} batteryInfo.battery - The current battery percentage
-             * @param {boolean} batteryInfo.plugged - Indicates if the phone is plugged in (true) or not (false)
-             * @deprecated
-             */
-            this.emit(Events.BATTERY_CHANGED, { battery, plugged });
-        });
+                    this.emit(Events.MESSAGE_REACTION, new Reaction(this, reaction));
+                }
+            });
 
-        await page.exposeFunction('onIncomingCall', (call) => {
-            /**
-             * Emitted when a call is received
-             * @event Client#incoming_call
-             * @param {object} call
-             * @param {number} call.id - Call id
-             * @param {string} call.peerJid - Who called
-             * @param {boolean} call.isVideo - if is video
-             * @param {boolean} call.isGroup - if is group
-             * @param {boolean} call.canHandleLocally - if we can handle in waweb
-             * @param {boolean} call.outgoing - if is outgoing
-             * @param {boolean} call.webClientShouldHandle - If Waweb should handle
-             * @param {object} call.participants - Participants
-             */
-            const cll = new Call(this, call);
-            this.emit(Events.INCOMING_CALL, cll);
-        });
+            await this.pupPage.exposeFunction('onRemoveChatEvent', async (chat) => {
+                const _chat = await this.getChatById(chat.id);
 
-        await page.exposeFunction('onReaction', (reactions) => {
-            for (const reaction of reactions) {
                 /**
-                 * Emitted when a reaction is sent, received, updated or removed
-                 * @event Client#message_reaction
-                 * @param {object} reaction
-                 * @param {object} reaction.id - Reaction id
-                 * @param {number} reaction.orphan - Orphan
-                 * @param {?string} reaction.orphanReason - Orphan reason
-                 * @param {number} reaction.timestamp - Timestamp
-                 * @param {string} reaction.reaction - Reaction
-                 * @param {boolean} reaction.read - Read
-                 * @param {object} reaction.msgId - Parent message id
-                 * @param {string} reaction.senderId - Sender id
-                 * @param {?number} reaction.ack - Ack
+                 * Emitted when a chat is removed
+                 * @event Client#chat_removed
+                 * @param {Chat} chat
                  */
-
-                this.emit(Events.MESSAGE_REACTION, new Reaction(this, reaction));
-            }
-        });
-
-        await page.exposeFunction('onRemoveChatEvent', async (chat) => {
-            const _chat = await this.getChatById(chat.id);
-
-            /**
-             * Emitted when a chat is removed
-             * @event Client#chat_removed
-             * @param {Chat} chat
-             */
-            this.emit(Events.CHAT_REMOVED, _chat);
-        });
-        
-        await page.exposeFunction('onArchiveChatEvent', async (chat, currState, prevState) => {
-            const _chat = await this.getChatById(chat.id);
+                this.emit(Events.CHAT_REMOVED, _chat);
+            });
             
-            /**
-             * Emitted when a chat is archived/unarchived
-             * @event Client#chat_archived
-             * @param {Chat} chat
-             * @param {boolean} currState
-             * @param {boolean} prevState
-             */
-            this.emit(Events.CHAT_ARCHIVED, _chat, currState, prevState);
-        });
+            await this.pupPage.exposeFunction('onArchiveChatEvent', async (chat, currState, prevState) => {
+                const _chat = await this.getChatById(chat.id);
+                
+                /**
+                 * Emitted when a chat is archived/unarchived
+                 * @event Client#chat_archived
+                 * @param {Chat} chat
+                 * @param {boolean} currState
+                 * @param {boolean} prevState
+                 */
+                this.emit(Events.CHAT_ARCHIVED, _chat, currState, prevState);
+            });
 
-        await page.exposeFunction('onEditMessageEvent', (msg, newBody, prevBody) => {
-            
-            if(msg.type === 'revoked'){
-                return;
-            }
-            /**
-             * Emitted when messages are edited
-             * @event Client#message_edit
-             * @param {Message} message
-             * @param {string} newBody
-             * @param {string} prevBody
-             */
-            this.emit(Events.MESSAGE_EDIT, new Message(this, msg), newBody, prevBody);
-        });
-        
-        await page.exposeFunction('onAddMessageCiphertextEvent', msg => {
+            await this.pupPage.exposeFunction('onEditMessageEvent', (msg, newBody, prevBody) => {
+                
+                if(msg.type === 'revoked'){
+                    return;
+                }
+                /**
+                 * Emitted when messages are edited
+                 * @event Client#message_edit
+                 * @param {Message} message
+                 * @param {string} newBody
+                 * @param {string} prevBody
+                 */
+                this.emit(Events.MESSAGE_EDIT, new Message(this, msg), newBody, prevBody);
+            });
             
-            /**
-             * Emitted when messages are edited
-             * @event Client#message_ciphertext
-             * @param {Message} message
-             */
-            this.emit(Events.MESSAGE_CIPHERTEXT, new Message(this, msg));
-        });
+            await this.pupPage.exposeFunction('onAddMessageCiphertextEvent', msg => {
+                
+                /**
+                 * Emitted when messages are edited
+                 * @event Client#message_ciphertext
+                 * @param {Message} message
+                 */
+                this.emit(Events.MESSAGE_CIPHERTEXT, new Message(this, msg));
+            });
+        }
 
-        await page.exposeFunction('onPollVoteEvent', (vote) => {
+        await this.pupPage.exposeFunction('onPollVoteEvent', (vote) => {
             const _vote = new PollVote(this, vote);
             /**
              * Emitted when some poll option is selected or deselected,
@@ -696,7 +697,7 @@ class Client extends EventEmitter {
             this.emit(Events.VOTE_UPDATE, _vote);
         });
 
-        await page.evaluate(() => {
+        await this.pupPage.evaluate(() => {
             window.Store.Msg.on('change', (msg) => { window.onChangeMessageEvent(window.WWebJS.getMessageModel(msg)); });
             window.Store.Msg.on('change:type', (msg) => { window.onChangeMessageTypeEvent(window.WWebJS.getMessageModel(msg)); });
             window.Store.Msg.on('change:ack', (msg, ack) => { window.onMessageAckEvent(window.WWebJS.getMessageModel(msg), ack); });
@@ -720,12 +721,28 @@ class Client extends EventEmitter {
                 }
             });
             window.Store.Chat.on('change:unreadCount', (chat) => {window.onChatUnreadCountEvent(chat);});
-            window.Store.PollVote.on('add', (vote) => {
-                const pollVoteModel = window.WWebJS.getPollVoteModel(vote);
+            window.Store.PollVote.on('add', async (vote) => {
+                const pollVoteModel = await window.WWebJS.getPollVoteModel(vote);
                 pollVoteModel && window.onPollVoteEvent(pollVoteModel);
             });
 
-            {
+            if (window.compareWwebVersions(window.Debug.VERSION, '>=', '2.3000.1014111620')) {
+                const module = window.Store.AddonReactionTable;
+                const ogMethod = module.bulkUpsert;
+                module.bulkUpsert = ((...args) => {
+                    window.onReaction(args[0].map(reaction => {
+                        const msgKey = reaction.id;
+                        const parentMsgKey = reaction.reactionParentKey;
+                        const timestamp = reaction.reactionTimestamp / 1000;
+                        const sender = reaction.author ?? reaction.from;
+                        const senderUserJid = sender._serialized;
+
+                        return {...reaction, msgKey, parentMsgKey, senderUserJid, timestamp };
+                    }));
+
+                    return ogMethod(...args);
+                }).bind(module);
+            } else {
                 const module = window.Store.createOrUpdateReactionsModule;
                 const ogMethod = module.createOrUpdateReactions;
                 module.createOrUpdateReactions = ((...args) => {
@@ -741,24 +758,7 @@ class Client extends EventEmitter {
                 }).bind(module);
             }
         });
-
-        /**
-         * Emitted when the client has initialized and is ready to receive messages.
-         * @event Client#ready
-         */
-        this.emit(Events.READY);
-        this.authStrategy.afterAuthReady();
-
-        // Disconnect when navigating away when in PAIRING state (detect logout)
-        this.pupPage.on('framenavigated', async () => {
-            const appState = await this.getState();
-            if(!appState || appState === WAState.PAIRING) {
-                await this.authStrategy.disconnect();
-                this.emit(Events.DISCONNECTED, 'NAVIGATION');
-                await this.destroy();
-            }
-        });
-    }
+    }    
 
     async initWebVersionCache() {
         const { type: webCacheType, ...webCacheOptions } = this.options.webVersionCache;
@@ -783,7 +783,8 @@ class Client extends EventEmitter {
         } else {
             this.pupPage.on('response', async (res) => {
                 if(res.ok() && res.url() === WhatsWebURL) {
-                    await webCache.persist(await res.text());
+                    const indexHtml = await res.text();
+                    this.currentIndexHtml = indexHtml;
                 }
             });
         }
@@ -802,7 +803,9 @@ class Client extends EventEmitter {
      */
     async logout() {
         await this.pupPage.evaluate(() => {
-            return window.Store.AppState.logout();
+            if (window.Store && window.Store.AppState && typeof window.Store.AppState.logout === 'function') {
+                return window.Store.AppState.logout();
+            }
         });
         await this.pupBrowser.close();
         
@@ -861,6 +864,7 @@ class Client extends EventEmitter {
      * @property {GroupMention[]} [groupMentions] - An array of object that handle group mentions
      * @property {string[]} [mentions] - User IDs to mention in the message
      * @property {boolean} [sendSeen=true] - Mark the conversation as seen after sending the message
+     * @property {string} [invokedBotWid=undefined] - Bot Wid when doing a bot mention like @Meta AI
      * @property {string} [stickerAuthor=undefined] - Sets the author of the sticker, (if sendMediaAsSticker is true).
      * @property {string} [stickerName=undefined] - Sets the name of the sticker, (if sendMediaAsSticker is true).
      * @property {string[]} [stickerCategories=undefined] - Sets the categories of the sticker, (if sendMediaAsSticker is true). Provide emoji char array, can be null.
@@ -894,9 +898,10 @@ class Client extends EventEmitter {
             sendMediaAsDocument: options.sendMediaAsDocument,
             caption: options.caption,
             quotedMessageId: options.quotedMessageId,
-            parseVCards: options.parseVCards === false ? false : true,
+            parseVCards: options.parseVCards !== false,
             mentionedJidList: options.mentions || [],
             groupMentions: options.groupMentions,
+            invokedBotWid: options.invokedBotWid,
             extraOptions: options.extra
         };
 
@@ -1032,7 +1037,7 @@ class Client extends EventEmitter {
             if(msg) return window.WWebJS.getMessageModel(msg);
 
             const params = messageId.split('_');
-            if(params.length !== 3) throw new Error('Invalid serialized message id specified');
+            if (params.length !== 3 && params.length !== 4) throw new Error('Invalid serialized message id specified');
 
             let messagesObject = await window.Store.Msg.getMessagesById([messageId]);
             if (messagesObject && messagesObject.messages.length) msg = messagesObject.messages[0];
@@ -1102,14 +1107,8 @@ class Client extends EventEmitter {
     async setDisplayName(displayName) {
         const couldSet = await this.pupPage.evaluate(async displayName => {
             if(!window.Store.Conn.canSetMyPushname()) return false;
-
-            if(window.Store.MDBackend) {
-                await window.Store.Settings.setPushname(displayName);
-                return true;
-            } else {
-                const res = await window.Store.Wap.setPushname(displayName);
-                return !res.status || res.status === 200;
-            }
+            await window.Store.Settings.setPushname(displayName);
+            return true;
         }, displayName);
 
         return couldSet;
@@ -1250,7 +1249,9 @@ class Client extends EventEmitter {
         const profilePic = await this.pupPage.evaluate(async contactId => {
             try {
                 const chatWid = window.Store.WidFactory.createWid(contactId);
-                return await window.Store.ProfilePic.profilePicFind(chatWid);
+                return window.compareWwebVersions(window.Debug.VERSION, '<', '2.3000.0')
+                    ? await window.Store.ProfilePic.profilePicFind(chatWid)
+                    : await window.Store.ProfilePic.requestProfilePicFromServer(chatWid);
             } catch (err) {
                 if(err.name === 'ServerStatusCodeError') return undefined;
                 throw err;
@@ -1416,10 +1417,18 @@ class Client extends EventEmitter {
 
             try {
                 createGroupResult = await window.Store.GroupUtils.createGroup(
-                    title,
-                    participantWids,
-                    messageTimer,
-                    parentGroupWid
+                    {
+                        'memberAddMode': options.memberAddMode === undefined ? true : options.memberAddMode,
+                        'membershipApprovalMode': options.membershipApprovalMode === undefined ? false : options.membershipApprovalMode,
+                        'announce': options.announce === undefined ? true : options.announce,
+                        'ephemeralDuration': messageTimer,
+                        'full': undefined,
+                        'parentGroupId': parentGroupWid,
+                        'restrict': options.restrict === undefined ? true : options.restrict,
+                        'thumb': undefined,
+                        'title': title,
+                    },
+                    participantWids
                 );
             } catch (err) {
                 return 'CreateGroupError: An unknown error occupied while creating a group';
@@ -1431,7 +1440,7 @@ class Client extends EventEmitter {
                 const statusCode = participant.error ?? 200;
 
                 if (autoSendInviteV4 && statusCode === 403) {
-                    window.Store.ContactCollection.gadd(participant.wid, { silent: true });
+                    window.Store.Contact.gadd(participant.wid, { silent: true });
                     const addParticipantResult = await window.Store.GroupInviteV4.sendGroupInviteMessage(
                         await window.Store.Chat.find(participant.wid),
                         createGroupResult.wid._serialized,
@@ -1608,8 +1617,8 @@ class Client extends EventEmitter {
      * @returns {Promise<Array<GroupMembershipRequest>>} An array of membership requests
      */
     async getGroupMembershipRequests(groupId) {
-        return await this.pupPage.evaluate(async (gropId) => {
-            const groupWid = window.Store.WidFactory.createWid(gropId);
+        return await this.pupPage.evaluate(async (groupId) => {
+            const groupWid = window.Store.WidFactory.createWid(groupId);
             return await window.Store.MembershipRequestUtils.getMembershipApprovalRequests(groupWid);
         }, groupId);
     }
@@ -1715,6 +1724,21 @@ class Client extends EventEmitter {
             return flag;
         }, flag);
     }
+
+    /**
+     * Get user device count by ID
+     * Each WaWeb Connection counts as one device, and the phone (if exists) counts as one
+     * So for a non-enterprise user with one WaWeb connection it should return "2"
+     * @param {string} contactId
+     * @returns {number}
+     */
+    async getContactDeviceCount(contactId) {
+        let devices = await window.Store.DeviceList.getDeviceIds([window.Store.WidFactory.createWid(contactId)]);
+        if(devices && devices.length  && devices[0] != null && typeof devices[0].devices == 'object'){
+            return devices[0].devices.length;
+        }
+        return 0;
+    }
 }
 
-module.exports = Client;
+module.exports = Client;