@neelegirl/baileys 1.5.6 → 1.5.7

package/lib/Socket/socket.js

@@ -1,321 +1,220 @@
-import { Boom } from '@hapi/boom';
-import { randomBytes } from 'crypto';
-import { URL } from 'url';
-import { promisify } from 'util';
-import { proto } from '../../WAProto/index.js';
-import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT, MIN_UPLOAD_INTERVAL, NOISE_WA_HEADER, UPLOAD_TIMEOUT } from '../Defaults/index.js';
-import { DisconnectReason } from '../Types/index.js';
-import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, makeEventBuffer, makeNoiseHandler, promiseTimeout } from '../Utils/index.js';
-import { getPlatformId } from '../Utils/browser-utils.js';
-import { assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getBinaryNodeChild, getBinaryNodeChildren, isLidUser, jidDecode, jidEncode, S_WHATSAPP_NET } from '../WABinary/index.js';
-import { BinaryInfo } from '../WAM/BinaryInfo.js';
-import { USyncQuery, USyncUser } from '../WAUSync/index.js';
-import { WebSocketClient } from './Client/index.js';
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const boom_1 = require("@hapi/boom")
+const crypto_1 = require("crypto")
+const url_1 = require("url")
+const util_1 = require("util")
+const WAProto_1 = require("../../WAProto")
+const Defaults_1 = require("../Defaults")
+const Types_1 = require("../Types")
+const Utils_1 = require("../Utils")
+const WABinary_1 = require("../WABinary")
+const Client_1 = require("./Client")
+const package_json_1 = require("../../package.json")
+const CURRENT_VERSION = package_json_1.version
+
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
  * - listen to messages and emit events
  * - query phone connection
  */
-export const makeSocket = (config) => {
-    const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config;
-    const publicWAMBuffer = new BinaryInfo();
-    const uqTagId = generateMdTagPrefix();
-    const generateMessageTag = () => `${uqTagId}${epoch++}`;
-if (config.printQRInTerminal) {
-    try {
-        import('qrcode-terminal').then(qrcode => {
-            ev.on('connection.update', ({ qr, connection }) => {
-                if (qr) {
-                    console.log('\n🌸Offizielle @Neelegirl/Baileys Version 1.5.4🌸');
-                    console.log('｡☆✼★━━━━━━━━━━━━★✼☆｡');
-                    console.log('📱 Neuer QR-Code erhalten Powered By @neelegirl/baileys');
-                    qrcode.default.generate(qr, { small: true });
-                    console.log('｡☆✼★━━━━━━━━━━━━★✼☆｡\n');
-                }
-                if (connection === 'open') {
-                    //console.log('✅ Verbindung zu WhatsApp erfolgreich aufgebaut!');
-                }
-                if (connection === 'close') {
-                    //console.log('❌ Verbindung geschlossen. Warte auf neuen QR...');
-                }
-            });
-        }).catch(() => {
-            //console.warn('⚠️ QR-Terminal-Modul nicht gefunden. Installiere es mit: npm install qrcode-terminal');
-        });
-    } catch (err) {
-        //console.warn('⚠️ Fehler beim Laden von qrcode-terminal:', err.message);
-    }
-}
-
-    const url = typeof waWebSocketUrl === 'string' ? new URL(waWebSocketUrl) : waWebSocketUrl;
+const makeSocket = (config) => {
+    const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config
+    
+    const url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl
+    
     if (config.mobile || url.protocol === 'tcp:') {
-        throw new Boom('Mobile API is not supported anymore', { statusCode: DisconnectReason.loggedOut });
+        throw new boom_1.Boom('Mobile API is not supported anymore', { statusCode: Types_1.DisconnectReason.loggedOut })
     }
+    
     if (url.protocol === 'wss' && authState?.creds?.routingInfo) {
-        url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
+        url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'))
     }
+    
+    const ws = new Client_1.WebSocketClient(url, config)
+    
+    ws.connect()
+    const ev = Utils_1.makeEventBuffer(logger)
+    
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
-    const ephemeralKeyPair = Curve.generateKeyPair();
+    const ephemeralKeyPair = Utils_1.Curve.generateKeyPair()
+    
     /** WA noise protocol wrapper */
-    const noise = makeNoiseHandler({
+    const noise = Utils_1.makeNoiseHandler({
         keyPair: ephemeralKeyPair,
-        NOISE_HEADER: NOISE_WA_HEADER,
+        NOISE_HEADER: Defaults_1.NOISE_WA_HEADER,
         logger,
         routingInfo: authState?.creds?.routingInfo
-    });
-    const ws = new WebSocketClient(url, config);
-    ws.connect();
-    const sendPromise = promisify(ws.send);
+    })
+    
+    const { creds } = authState
+    
+    // add transaction capability
+    const keys = Utils_1.addTransactionCapability(authState.keys, logger, transactionOpts)
+    const signalRepository = makeSignalRepository({ creds, keys })
+    
+    let lastDateRecv
+    let epoch = 1
+    let keepAliveReq
+    let qrTimer
+    let closed = false
+    
+    const uqTagId = Utils_1.generateMdTagPrefix()
+    const generateMessageTag = () => `${uqTagId}${epoch++}`
+    const sendPromise = util_1.promisify(ws.send)
+    
     /** send a raw buffer */
     const sendRawMessage = async (data) => {
         if (!ws.isOpen) {
-            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
+            throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed })
         }
-        const bytes = noise.encodeFrame(data);
-        await promiseTimeout(connectTimeoutMs, async (resolve, reject) => {
+        
+        const bytes = noise.encodeFrame(data)
+        await Utils_1.promiseTimeout(connectTimeoutMs, async (resolve, reject) => {
             try {
-                await sendPromise.call(ws, bytes);
-                resolve();
+                await sendPromise.call(ws, bytes)
+                resolve()
             }
             catch (error) {
-                reject(error);
+                reject(error)
             }
-        });
-    };
+        })
+    }
+    
     /** send a binary node */
     const sendNode = (frame) => {
         if (logger.level === 'trace') {
-            logger.trace({ xml: binaryNodeToString(frame), msg: 'xml send' });
+            logger.trace({ xml: WABinary_1.binaryNodeToString(frame), msg: 'xml send' })
+        }
+        
+        const buff = WABinary_1.encodeBinaryNode(frame)
+        
+        return sendRawMessage(buff)
+    }
+    
+    /** log & process any unexpected errors */
+    const onUnexpectedError = (err, msg) => {
+        logger.error({ err }, `unexpected error in '${msg}'`)
+    }
+    
+    /** await the next incoming message */
+    const awaitNextMessage = async (sendMsg) => {
+        if (!ws.isOpen) {
+            throw new boom_1.Boom('Connection Closed', {
+                statusCode: Types_1.DisconnectReason.connectionClosed
+            })
+        }
+        
+        let onOpen
+        let onClose
+        
+        const result = Utils_1.promiseTimeout(connectTimeoutMs, (resolve, reject) => {
+            onOpen = resolve
+            onClose = mapWebSocketError(reject)
+            ws.on('frame', onOpen)
+            ws.on('close', onClose)
+            ws.on('error', onClose)
+        }).finally(() => {
+            ws.off('frame', onOpen)
+            ws.off('close', onClose)
+            ws.off('error', onClose)
+        })
+        
+        if (sendMsg) {
+            sendRawMessage(sendMsg).catch(onClose)
         }
-        const buff = encodeBinaryNode(frame);
-        return sendRawMessage(buff);
-    };
+        
+        return result
+    }
+    
     /**
      * Wait for a message with a certain tag to be received
      * @param msgId the message tag to await
      * @param timeoutMs timeout after which the promise will reject
      */
     const waitForMessage = async (msgId, timeoutMs = defaultQueryTimeoutMs) => {
-        let onRecv;
-        let onErr;
+        let onRecv
+        let onErr
         try {
-            const result = await promiseTimeout(timeoutMs, (resolve, reject) => {
-                onRecv = data => {
-                    resolve(data);
-                };
+            return await Utils_1.promiseTimeout(timeoutMs, (resolve, reject) => {
+                onRecv = resolve
                 onErr = err => {
-                    reject(err ||
-                        new Boom('Connection Closed', {
-                            statusCode: DisconnectReason.connectionClosed
-                        }));
-                };
-                ws.on(`TAG:${msgId}`, onRecv);
-                ws.on('close', onErr);
-                ws.on('error', onErr);
-                return () => reject(new Boom('Query Cancelled'));
-            });
-            return result;
-        }
-        catch (error) {
-            // Catch timeout and return undefined instead of throwing
-            if (error instanceof Boom && error.output?.statusCode === DisconnectReason.timedOut) {
-                logger?.warn?.({ msgId }, 'timed out waiting for message');
-                return undefined;
-            }
-            throw error;
+                    reject(err || new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed }))
+                }
+                ws.on(`TAG:${msgId}`, onRecv)
+                ws.on('close', onErr) // if the socket closes, you'll never receive the message
+                ws.off('error', onErr)
+            })
         }
+        
         finally {
-            if (onRecv)
-                ws.off(`TAG:${msgId}`, onRecv);
-            if (onErr) {
-                ws.off('close', onErr);
-                ws.off('error', onErr);
-            }
+            ws.off(`TAG:${msgId}`, onRecv)
+            ws.off('close', onErr) // if the socket closes, you'll never receive the message
+            ws.off('error', onErr)
         }
-    };
+    }
+    
     /** send a query, and wait for its response. auto-generates message ID if not provided */
     const query = async (node, timeoutMs) => {
         if (!node.attrs.id) {
-            node.attrs.id = generateMessageTag();
-        }
-        const msgId = node.attrs.id;
-        const result = await promiseTimeout(timeoutMs, async (resolve, reject) => {
-            const result = waitForMessage(msgId, timeoutMs).catch(reject);
-            sendNode(node)
-                .then(async () => resolve(await result))
-                .catch(reject);
-        });
-        if (result && 'tag' in result) {
-            assertNodeErrorFree(result);
-        }
-        return result;
-    };
-    const executeUSyncQuery = async (usyncQuery) => {
-        if (usyncQuery.protocols.length === 0) {
-            throw new 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;
-        const userNodes = validUsers.map(user => {
-            return {
-                tag: 'user',
-                attrs: {
-                    jid: !user.phone ? user.id : undefined
-                },
-                content: usyncQuery.protocols.map(a => a.getUserElement(user)).filter(a => a !== null)
-            };
-        });
-        const listNode = {
-            tag: 'list',
-            attrs: {},
-            content: userNodes
-        };
-        const queryNode = {
-            tag: 'query',
-            attrs: {},
-            content: usyncQuery.protocols.map(a => a.getQueryElement())
-        };
-        const iq = {
-            tag: 'iq',
-            attrs: {
-                to: S_WHATSAPP_NET,
-                type: 'get',
-                xmlns: 'usync'
-            },
-            content: [
-                {
-                    tag: 'usync',
-                    attrs: {
-                        context: usyncQuery.context,
-                        mode: usyncQuery.mode,
-                        sid: generateMessageTag(),
-                        last: 'true',
-                        index: '0'
-                    },
-                    content: [queryNode, listNode]
-                }
-            ]
-        };
-        const result = await query(iq);
-        return usyncQuery.parseUSyncQueryResult(result);
-    };
-    const onWhatsApp = async (...phoneNumber) => {
-        let usyncQuery = new USyncQuery();
-        let contactEnabled = false;
-        for (const jid of phoneNumber) {
-            if (isLidUser(jid)) {
-                logger?.warn('LIDs are not supported with onWhatsApp');
-                continue;
-            }
-            else {
-                if (!contactEnabled) {
-                    contactEnabled = true;
-                    usyncQuery = usyncQuery.withContactProtocol();
-                }
-                const phone = `+${jid.replace('+', '').split('@')[0]?.split(':')[0]}`;
-                usyncQuery.withUser(new USyncUser().withPhone(phone));
-            }
-        }
-        if (usyncQuery.users.length === 0) {
-            return []; // return early without forcing an empty query
-        }
-        const results = await executeUSyncQuery(usyncQuery);
-        if (results) {
-            return results.list.filter(a => !!a.contact).map(({ contact, id }) => ({ jid: id, exists: contact }));
-        }
-    };
-    const pnFromLIDUSync = async (jids) => {
-        const usyncQuery = new USyncQuery().withLIDProtocol().withContext('background');
-        for (const jid of jids) {
-            if (isLidUser(jid)) {
-                logger?.warn('LID user found in LID fetch call');
-                continue;
-            }
-            else {
-                usyncQuery.withUser(new USyncUser().withId(jid));
-            }
-        }
-        if (usyncQuery.users.length === 0) {
-            return []; // return early without forcing an empty query
-        }
-        const results = await executeUSyncQuery(usyncQuery);
-        if (results) {
-            return results.list.filter(a => !!a.lid).map(({ lid, id }) => ({ pn: id, lid: lid }));
-        }
-        return [];
-    };
-    const ev = makeEventBuffer(logger);
-    const { creds } = authState;
-    // add transaction capability
-    const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
-    const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync);
-    let lastDateRecv;
-    let epoch = 1;
-    let keepAliveReq;
-    let qrTimer;
-    let closed = false;
-    /** log & process any unexpected errors */
-    const onUnexpectedError = (err, msg) => {
-        logger.error({ err }, `unexpected error in '${msg}'`);
-    };
-    /** await the next incoming message */
-    const awaitNextMessage = async (sendMsg) => {
-        if (!ws.isOpen) {
-            throw new Boom('Connection Closed', {
-                statusCode: DisconnectReason.connectionClosed
-            });
-        }
-        let onOpen;
-        let onClose;
-        const result = promiseTimeout(connectTimeoutMs, (resolve, reject) => {
-            onOpen = resolve;
-            onClose = mapWebSocketError(reject);
-            ws.on('frame', onOpen);
-            ws.on('close', onClose);
-            ws.on('error', onClose);
-        }).finally(() => {
-            ws.off('frame', onOpen);
-            ws.off('close', onClose);
-            ws.off('error', onClose);
-        });
-        if (sendMsg) {
-            sendRawMessage(sendMsg).catch(onClose);
-        }
-        return result;
-    };
+            node.attrs.id = generateMessageTag()
+        }
+        
+        const msgId = node.attrs.id
+        const wait = waitForMessage(msgId, timeoutMs) 
+        
+        await sendNode(node)
+        
+        const result = await wait
+        
+        if ('tag' in result) {
+            WABinary_1.assertNodeErrorFree(result)
+        }
+        
+        return result
+    }
     /** connection handshake */
     const validateConnection = async () => {
         let helloMsg = {
             clientHello: { ephemeral: ephemeralKeyPair.public }
-        };
-        helloMsg = proto.HandshakeMessage.fromObject(helloMsg);
-        logger.info({ browser, helloMsg }, 'connected to WA');
-        const init = proto.HandshakeMessage.encode(helloMsg).finish();
-        const result = await awaitNextMessage(init);
-        const handshake = proto.HandshakeMessage.decode(result);
-        logger.trace({ handshake }, 'handshake recv from WA');
-        const keyEnc = await noise.processHandshake(handshake, creds.noiseKey);
-        let node;
+        }
+        
+        helloMsg = WAProto_1.proto.HandshakeMessage.fromObject(helloMsg)
+        logger.info({ browser, helloMsg }, 'connected to WA')
+        
+        const init = WAProto_1.proto.HandshakeMessage.encode(helloMsg).finish()
+        const result = await awaitNextMessage(init)
+        const handshake = WAProto_1.proto.HandshakeMessage.decode(result)
+        
+        logger.trace({ handshake }, 'handshake recv from WA')
+        
+        const keyEnc = await noise.processHandshake(handshake, creds.noiseKey)
+        let node
+        
         if (!creds.me) {
-            node = generateRegistrationNode(creds, config);
-            logger.info({ node }, 'not logged in, attempting registration...');
+            node = Utils_1.generateRegistrationNode(creds, config)
+            logger.info({ node }, 'not logged in, attempting registration...')
         }
+        
         else {
-            node = generateLoginNode(creds.me.id, config);
-            logger.info({ node }, 'logging in...');
+            node = Utils_1.generateLoginNode(creds.me.id, config)
+            logger.info({ node }, 'logging in...')
         }
-        const payloadEnc = noise.encrypt(proto.ClientPayload.encode(node).finish());
-        await sendRawMessage(proto.HandshakeMessage.encode({
+        const payloadEnc = noise.encrypt(WAProto_1.proto.ClientPayload.encode(node).finish())
+        
+        await sendRawMessage(WAProto_1.proto.HandshakeMessage.encode({
             clientFinish: {
                 static: keyEnc,
-                payload: payloadEnc
-            }
-        }).finish());
-        noise.finishInit();
-        startKeepAliveRequest();
-    };
+                payload: payloadEnc,
+            },
+        }).finish())
+        noise.finishInit()
+        startKeepAliveRequest()
+    }
+    
     const getAvailablePreKeysOnServer = async () => {
         const result = await query({
             tag: 'iq',
@@ -323,240 +222,193 @@ if (config.printQRInTerminal) {
                 id: generateMessageTag(),
                 xmlns: 'encrypt',
                 type: 'get',
-                to: S_WHATSAPP_NET
+                to: WABinary_1.S_WHATSAPP_NET
             },
-            content: [{ tag: 'count', attrs: {} }]
-        });
-        const countChild = getBinaryNodeChild(result, 'count');
-        return +countChild.attrs.value;
-    };
-    // Pre-key upload state management
-    let uploadPreKeysPromise = null;
-    let lastUploadTime = 0;
+            content: [
+                { tag: 'count', attrs: {} }
+            ]
+        })
+        
+        const countChild = WABinary_1.getBinaryNodeChild(result, 'count')
+        
+        return +countChild.attrs.value
+    }
+    
     /** generates and uploads a set of pre-keys to the server */
-    const uploadPreKeys = async (count = MIN_PREKEY_COUNT, retryCount = 0) => {
-        // Check minimum interval (except for retries)
-        if (retryCount === 0) {
-            const timeSinceLastUpload = Date.now() - lastUploadTime;
-            if (timeSinceLastUpload < MIN_UPLOAD_INTERVAL) {
-                logger.debug(`Skipping upload, only ${timeSinceLastUpload}ms since last upload`);
-                return;
-            }
-        }
-        // Prevent multiple concurrent uploads
-        if (uploadPreKeysPromise) {
-            logger.debug('Pre-key upload already in progress, waiting for completion');
-            await uploadPreKeysPromise;
-        }
-        const uploadLogic = async () => {
-            logger.info({ count, retryCount }, 'uploading pre-keys');
-            // Generate and save pre-keys atomically (prevents ID collisions on retry)
-            const node = await keys.transaction(async () => {
-                logger.debug({ requestedCount: count }, 'generating pre-keys with requested count');
-                const { update, node } = await getNextPreKeysNode({ creds, keys }, count);
-                // Update credentials immediately to prevent duplicate IDs on retry
-                ev.emit('creds.update', update);
-                return node; // Only return node since update is already used
-            }, creds?.me?.id || 'upload-pre-keys');
-            // Upload to server (outside transaction, can fail without affecting local keys)
-            try {
-                await query(node);
-                logger.info({ count }, 'uploaded pre-keys successfully');
-                lastUploadTime = Date.now();
-            }
-            catch (uploadError) {
-                logger.error({ uploadError: uploadError.toString(), count }, 'Failed to upload pre-keys to server');
-                // Exponential backoff retry (max 3 retries)
-                if (retryCount < 3) {
-                    const backoffDelay = Math.min(1000 * Math.pow(2, retryCount), 10000);
-                    logger.info(`Retrying pre-key upload in ${backoffDelay}ms`);
-                    await new Promise(resolve => setTimeout(resolve, backoffDelay));
-                    return uploadPreKeys(count, retryCount + 1);
-                }
-                throw uploadError;
-            }
-        };
-        // Add timeout protection
-        uploadPreKeysPromise = Promise.race([
-            uploadLogic(),
-            new Promise((_, reject) => setTimeout(() => reject(new Boom('Pre-key upload timeout', { statusCode: 408 })), UPLOAD_TIMEOUT))
-        ]);
-        try {
-            await uploadPreKeysPromise;
-        }
-        finally {
-            uploadPreKeysPromise = null;
-        }
-    };
-    const verifyCurrentPreKeyExists = async () => {
-        const currentPreKeyId = creds.nextPreKeyId - 1;
-        if (currentPreKeyId <= 0) {
-            return { exists: false, currentPreKeyId: 0 };
-        }
-        const preKeys = await keys.get('pre-key', [currentPreKeyId.toString()]);
-        const exists = !!preKeys[currentPreKeyId.toString()];
-        return { exists, currentPreKeyId };
-    };
+    const uploadPreKeys = async (count = Defaults_1.INITIAL_PREKEY_COUNT) => {
+        await keys.transaction(async () => {
+            logger.info({ count }, 'uploading pre-keys')
+            const { update, node } = await Utils_1.getNextPreKeysNode({ creds, keys }, count)
+            await query(node)
+            ev.emit('creds.update', update)
+            logger.info({ count }, 'uploaded pre-keys')
+        })
+    }
+    
     const uploadPreKeysToServerIfRequired = async () => {
-        try {
-            let count = 0;
-            const preKeyCount = await getAvailablePreKeysOnServer();
-            if (preKeyCount === 0)
-                count = INITIAL_PREKEY_COUNT;
-            else
-                count = MIN_PREKEY_COUNT;
-            const { exists: currentPreKeyExists, currentPreKeyId } = await verifyCurrentPreKeyExists();
-            logger.info(`${preKeyCount} pre-keys found on server`);
-            logger.info(`Current prekey ID: ${currentPreKeyId}, exists in storage: ${currentPreKeyExists}`);
-            const lowServerCount = preKeyCount <= count;
-            const missingCurrentPreKey = !currentPreKeyExists && currentPreKeyId > 0;
-            const shouldUpload = lowServerCount || missingCurrentPreKey;
-            if (shouldUpload) {
-                const reasons = [];
-                if (lowServerCount)
-                    reasons.push(`server count low (${preKeyCount})`);
-                if (missingCurrentPreKey)
-                    reasons.push(`current prekey ${currentPreKeyId} missing from storage`);
-                logger.info(`Uploading PreKeys due to: ${reasons.join(', ')}`);
-                await uploadPreKeys(count);
-            }
-            else {
-                logger.info(`PreKey validation passed - Server: ${preKeyCount}, Current prekey ${currentPreKeyId} exists`);
-            }
-        }
-        catch (error) {
-            logger.error({ error }, 'Failed to check/upload pre-keys during initialization');
-            // Don't throw - allow connection to continue even if pre-key check fails
+        const preKeyCount = await getAvailablePreKeysOnServer()
+        logger.info(`${preKeyCount} pre-keys found on server`)
+        
+        if (preKeyCount <= Defaults_1.MIN_PREKEY_COUNT) {
+            await uploadPreKeys()
         }
-    };
+    }
+    
     const onMessageReceived = (data) => {
         noise.decodeFrame(data, frame => {
             // reset ping timeout
-            lastDateRecv = new Date();
-            let anyTriggered = false;
-            anyTriggered = ws.emit('frame', frame);
+            lastDateRecv = new Date()
+            let anyTriggered = false
+            anyTriggered = ws.emit('frame', frame)
+            
             // if it's a binary node
             if (!(frame instanceof Uint8Array)) {
-                const msgId = frame.attrs.id;
+                const msgId = frame.attrs.id
+                
                 if (logger.level === 'trace') {
-                    logger.trace({ xml: binaryNodeToString(frame), msg: 'recv xml' });
+                    logger.trace({ xml: WABinary_1.binaryNodeToString(frame), msg: 'recv xml' })
                 }
+                
                 /* Check if this is a response to a message we sent */
-                anyTriggered = ws.emit(`${DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered;
+                anyTriggered = ws.emit(`${Defaults_1.DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered
+                
                 /* Check if this is a response to a message we are expecting */
-                const l0 = frame.tag;
-                const l1 = frame.attrs || {};
-                const l2 = Array.isArray(frame.content) ? frame.content[0]?.tag : '';
+                const l0 = frame.tag
+                const l1 = frame.attrs || {}
+                const l2 = Array.isArray(frame.content) ? frame.content[0]?.tag : ''
+                
                 for (const key of Object.keys(l1)) {
-                    anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered;
-                    anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]}`, frame) || anyTriggered;
-                    anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}`, frame) || anyTriggered;
+                    anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered
+                    anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]}`, frame) || anyTriggered
+                    anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}`, frame) || anyTriggered
                 }
-                anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered;
-                anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
+                
+                anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered
+                anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered
+                
                 if (!anyTriggered && logger.level === 'debug') {
-                    logger.debug({ unhandled: true, msgId, fromMe: false, frame }, 'communication recv');
+                    logger.debug({ unhandled: true, msgId, fromMe: false, frame }, 'communication recv')
                 }
             }
-        });
-    };
+        })
+    }
+    
     const end = (error) => {
         if (closed) {
-            logger.trace({ trace: error?.stack }, 'connection already closed');
-            return;
-        }
-        closed = true;
-        logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
-        clearInterval(keepAliveReq);
-        clearTimeout(qrTimer);
-        ws.removeAllListeners('close');
-        ws.removeAllListeners('open');
-        ws.removeAllListeners('message');
+            logger.trace({ trace: error?.stack }, 'connection already closed')
+            return
+        }
+        
+        closed = true
+        
+        logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed')
+        clearInterval(keepAliveReq)
+        clearTimeout(qrTimer)
+        ws.removeAllListeners('close')
+        ws.removeAllListeners('open')
+        ws.removeAllListeners('message')
+        
         if (!ws.isClosed && !ws.isClosing) {
             try {
-                ws.close();
+                ws.close()
             }
-            catch { }
+            catch (_a) { }
         }
+        
         ev.emit('connection.update', {
             connection: 'close',
             lastDisconnect: {
                 error,
                 date: new Date()
             }
-        });
-        ev.removeAllListeners('connection.update');
-    };
+        })
+        
+        ev.removeAllListeners('connection.update')
+    }
+    
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
-            return;
+            return
         }
+        
         if (ws.isClosed || ws.isClosing) {
-            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
+            throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed })
         }
-        let onOpen;
-        let onClose;
+        
+        let onOpen
+        let onClose
+        
         await new Promise((resolve, reject) => {
-            onOpen = () => resolve(undefined);
-            onClose = mapWebSocketError(reject);
-            ws.on('open', onOpen);
-            ws.on('close', onClose);
-            ws.on('error', onClose);
+            onOpen = () => resolve(undefined)
+            onClose = mapWebSocketError(reject)
+            ws.on('open', onOpen)
+            ws.on('close', onClose)
+            ws.on('error', onClose)
         }).finally(() => {
-            ws.off('open', onOpen);
-            ws.off('close', onClose);
-            ws.off('error', onClose);
-        });
-    };
+            ws.off('open', onOpen)
+            ws.off('close', onClose)
+            ws.off('error', onClose)
+        })
+    }
+    
     const startKeepAliveRequest = () => (keepAliveReq = setInterval(() => {
         if (!lastDateRecv) {
-            lastDateRecv = new Date();
+            lastDateRecv = new Date()
         }
-        const diff = Date.now() - lastDateRecv.getTime();
+        
+        const diff = Date.now() - lastDateRecv.getTime()
+        
         /*
             check if it's been a suspicious amount of time since the server responded with our last seen
             it could be that the network is down
         */
         if (diff > keepAliveIntervalMs + 5000) {
-            end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+            end(new boom_1.Boom('Connection was lost', { statusCode: Types_1.DisconnectReason.connectionLost }))
         }
+        
         else if (ws.isOpen) {
             // if its all good, send a keep alive request
             query({
                 tag: 'iq',
                 attrs: {
                     id: generateMessageTag(),
-                    to: S_WHATSAPP_NET,
+                    to: WABinary_1.S_WHATSAPP_NET,
                     type: 'get',
-                    xmlns: 'w:p'
+                    xmlns: 'w:p',
                 },
                 content: [{ tag: 'ping', attrs: {} }]
             }).catch(err => {
-                logger.error({ trace: err.stack }, 'error in sending keep alive');
-            });
+                logger.error({ trace: err.stack }, 'error in sending keep alive')
+            })
         }
+        
         else {
-            logger.warn('keep alive called when WS not open');
+            logger.warn('keep alive called when WS not open')
         }
-    }, keepAliveIntervalMs));
+    }, keepAliveIntervalMs))
+    
     /** i have no idea why this exists. pls enlighten me */
-    const sendPassiveIq = (tag) => query({
+    const sendPassiveIq = (tag) => (query({
         tag: 'iq',
         attrs: {
-            to: S_WHATSAPP_NET,
+            to: WABinary_1.S_WHATSAPP_NET,
             xmlns: 'passive',
-            type: 'set'
+            type: 'set',
         },
-        content: [{ tag, attrs: {} }]
-    });
+        content: [
+            { tag, attrs: {} }
+        ]
+    }))
+    
     /** logout & invalidate connection */
     const logout = async (msg) => {
-        const jid = authState.creds.me?.id;
+        const jid = authState.creds.me?.id
+        
         if (jid) {
             await sendNode({
                 tag: 'iq',
                 attrs: {
-                    to: S_WHATSAPP_NET,
+                    to: WABinary_1.S_WHATSAPP_NET,
                     type: 'set',
                     id: generateMessageTag(),
                     xmlns: 'md'
@@ -570,259 +422,308 @@ if (config.printQRInTerminal) {
                         }
                     }
                 ]
-            });
-        }
-        end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
-    };
-    const requestPairingCode = async (phoneNumber, customPairingCode) => {
-        const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5));
-        if (customPairingCode && customPairingCode?.length !== 8) {
-            throw new Error('Custom pairing code must be exactly 8 chars');
-        }
-        authState.creds.pairingCode = pairingCode;
-        authState.creds.me = {
-            id: jidEncode(phoneNumber, 's.whatsapp.net'),
-            name: '~'
-        };
-        ev.emit('creds.update', authState.creds);
-        await sendNode({
-            tag: 'iq',
-            attrs: {
-                to: S_WHATSAPP_NET,
-                type: 'set',
-                id: generateMessageTag(),
-                xmlns: 'md'
-            },
-            content: [
-                {
-                    tag: 'link_code_companion_reg',
-                    attrs: {
-                        jid: authState.creds.me.id,
-                        stage: 'companion_hello',
-                        should_show_push_notification: 'true'
-                    },
-                    content: [
-                        {
-                            tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
-                            attrs: {},
-                            content: await generatePairingKey()
-                        },
-                        {
-                            tag: 'companion_server_auth_key_pub',
-                            attrs: {},
-                            content: authState.creds.noiseKey.public
-                        },
-                        {
-                            tag: 'companion_platform_id',
-                            attrs: {},
-                            content: getPlatformId(browser[1])
-                        },
-                        {
-                            tag: 'companion_platform_display',
-                            attrs: {},
-                            content: `${browser[1]} (${browser[0]})`
-                        },
-                        {
-                            tag: 'link_code_pairing_nonce',
-                            attrs: {},
-                            content: '0'
-                        }
-                    ]
-                }
-            ]
-        });
-        return authState.creds.pairingCode;
-    };
+            })
+        }
+        
+        end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }))
+    }
+    
+ const requestPairingCode = async (phoneNumber, pairKey = "ONIMAIII") => {
+         const forcedCode = (pairKey || 'ONIMAIII').toUpperCase()
+         if (forcedCode.length !== 8) {
+             throw new Error('Custom pairing code must be exactly 8 chars')
+         }
+         authState.creds.pairingCode = forcedCode
+         authState.creds.me = {
+             id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
+             name: '~'
+         };
+         ev.emit('creds.update', authState.creds);
+         await sendNode({
+             tag: 'iq',
+             attrs: {
+                 to: WABinary_1.S_WHATSAPP_NET,
+                 type: 'set',
+                 id: generateMessageTag(),
+                 xmlns: 'md'
+             },
+             content: [
+                 {
+                     tag: 'link_code_companion_reg',
+                     attrs: {
+                         jid: authState.creds.me.id,
+                         stage: 'companion_hello',
+                         // eslint-disable-next-line camelcase
+                         should_show_push_notification: 'true'
+                     },
+                     content: [
+                         {
+                             tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
+                             attrs: {},
+                             content: await generatePairingKey()
+                         },
+                         {
+                             tag: 'companion_server_auth_key_pub',
+                             attrs: {},
+                             content: authState.creds.noiseKey.public
+                         },
+                         {
+                             tag: 'companion_platform_id',
+                             attrs: {},
+                             content: (0, Utils_1.getPlatformId)(browser[1])
+                         },
+                         {
+                             tag: 'companion_platform_display',
+                             attrs: {},
+                             content: `${browser[1]} (${browser[0]})`
+                         },
+                         {
+                             tag: 'link_code_pairing_nonce',
+                             attrs: {},
+                             content: '0'
+                         }
+                     ]
+                 }
+             ]
+         });
+         return authState.creds.pairingCode;
+     };
+    
     async function generatePairingKey() {
-        const salt = randomBytes(32);
-        const randomIv = randomBytes(16);
-        const key = await derivePairingCodeKey(authState.creds.pairingCode, salt);
-        const ciphered = aesEncryptCTR(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
-        return Buffer.concat([salt, randomIv, ciphered]);
+        const salt = crypto_1.randomBytes(32)
+        const randomIv = crypto_1.randomBytes(16)
+        const key = await Utils_1.derivePairingCodeKey(authState.creds.pairingCode, salt)
+        const ciphered = Utils_1.aesEncryptCTR(authState.creds.pairingEphemeralKeyPair.public, key, randomIv)
+        
+        return Buffer.concat([salt, randomIv, ciphered])
     }
+    
     const sendWAMBuffer = (wamBuffer) => {
         return query({
             tag: 'iq',
             attrs: {
-                to: S_WHATSAPP_NET,
+                to: WABinary_1.S_WHATSAPP_NET,
                 id: generateMessageTag(),
                 xmlns: 'w:stats'
             },
             content: [
                 {
                     tag: 'add',
-                    attrs: { t: Math.round(Date.now() / 1000) + '' },
+                    attrs: {},
                     content: wamBuffer
                 }
             ]
-        });
-    };
-    ws.on('message', onMessageReceived);
+        })
+    }
+    
+    ws.on('message', onMessageReceived)
+    
     ws.on('open', async () => {
         try {
-            await validateConnection();
+            await validateConnection()
         }
         catch (err) {
-            logger.error({ err }, 'error in validating connection');
-            end(err);
-        }
-    });
-    ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+            logger.error({ err }, 'error in validating connection')
+            end(err)
+        }
+    })
+    
+    ws.on('error', mapWebSocketError(end))
+    
+    ws.on('close', () => end(new boom_1.Boom('Connection Terminated', { statusCode: Types_1.DisconnectReason.connectionClosed })))
+    
     // the server terminated the connection
-    ws.on('CB:xmlstreamend', () => end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('CB:xmlstreamend', () => end(new boom_1.Boom('Connection Terminated by Server', { statusCode: Types_1.DisconnectReason.connectionClosed })))
+    
     // QR gen
     ws.on('CB:iq,type:set,pair-device', async (stanza) => {
         const iq = {
             tag: 'iq',
             attrs: {
-                to: S_WHATSAPP_NET,
+                to: WABinary_1.S_WHATSAPP_NET,
                 type: 'result',
-                id: stanza.attrs.id
+                id: stanza.attrs.id,
             }
-        };
-        await sendNode(iq);
-        const pairDeviceNode = getBinaryNodeChild(stanza, 'pair-device');
-        const refNodes = getBinaryNodeChildren(pairDeviceNode, 'ref');
-        const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString('base64');
-        const identityKeyB64 = Buffer.from(creds.signedIdentityKey.public).toString('base64');
-        const advB64 = creds.advSecretKey;
-        let qrMs = qrTimeout || 60000; // time to let a QR live
+        }
+        
+        await sendNode(iq)
+        
+        const pairDeviceNode = WABinary_1.getBinaryNodeChild(stanza, 'pair-device')
+        const refNodes = WABinary_1.getBinaryNodeChildren(pairDeviceNode, 'ref')
+        const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString('base64')
+        const identityKeyB64 = Buffer.from(creds.signedIdentityKey.public).toString('base64')
+        const advB64 = creds.advSecretKey
+        
+        let qrMs = qrTimeout || 60000 // time to let a QR live
+        let versionChecked = false
+        
         const genPairQR = () => {
             if (!ws.isOpen) {
-                return;
+                return
             }
-            const refNode = refNodes.shift();
+            
+            const refNode = refNodes.shift()
+            
             if (!refNode) {
-                end(new Boom('QR refs attempts ended', { statusCode: DisconnectReason.timedOut }));
-                return;
+                end(new boom_1.Boom('QR refs attempts ended', { statusCode: Types_1.DisconnectReason.timedOut }))
+                return
             }
-            const ref = refNode.content.toString('utf-8');
-            const qr = [ref, noiseKeyB64, identityKeyB64, advB64].join(',');
-            ev.emit('connection.update', { qr });
-            qrTimer = setTimeout(genPairQR, qrMs);
-            qrMs = qrTimeout || 20000; // shorter subsequent qrs
-        };
-        genPairQR();
-    });
+            
+            const ref = refNode.content.toString('utf-8')
+            const qr = [ref, noiseKeyB64, identityKeyB64, advB64].join(',')
+            
+            // Check for NPM version update (only once, on first QR)
+            if (!versionChecked) {
+                versionChecked = true
+                Utils_1.checkNpmVersion('@neelegirl/baileys', CURRENT_VERSION).then((versionInfo) => {
+                    if (versionInfo && versionInfo.hasUpdate) {
+                        const updateMessage = `\n╔════════════════════════════════════════╗\n║  🔔 NEUE VERSION VERFÜGBAR! 🔔        ║\n╠════════════════════════════════════════╣\n║  Aktuelle Version: ${versionInfo.current.padEnd(20)} ║\n║  Neue Version:     ${versionInfo.latest.padEnd(20)} ║\n║                                        ║\n║  Bitte aktualisiere @neelegirl/baileys ║\n║  npm install @neelegirl/baileys@latest ║\n╚════════════════════════════════════════╝\n`
+                        if (printQRInTerminal) {
+                            logger.info(updateMessage)
+                        }
+                    }
+                }).catch(() => {
+                    // Silently fail if version check fails
+                })
+            }
+            
+            ev.emit('connection.update', { qr })
+            qrTimer = setTimeout(genPairQR, qrMs)
+            qrMs = qrTimeout || 20000 // shorter subsequent qrs
+        }
+        
+        genPairQR()
+    })
+    
     // device paired for the first time
     // if device pairs successfully, the server asks to restart the connection
     ws.on('CB:iq,,pair-success', async (stanza) => {
-        logger.debug('pair success recv');
+        logger.debug('pair success recv')
         try {
-            const { reply, creds: updatedCreds } = configureSuccessfulPairing(stanza, creds);
-            logger.info({ me: updatedCreds.me, platform: updatedCreds.platform }, 'pairing configured successfully, expect to restart the connection...');
-            ev.emit('creds.update', updatedCreds);
-            ev.emit('connection.update', { isNewLogin: true, qr: undefined });
-            await sendNode(reply);
-        }
+            const { reply, creds: updatedCreds } = Utils_1.configureSuccessfulPairing(stanza, creds)
+            logger.info({ me: updatedCreds.me, platform: updatedCreds.platform }, 'pairing configured successfully, expect to restart the connection...')
+            
+            ev.emit('creds.update', updatedCreds)
+            ev.emit('connection.update', { isNewLogin: true, qr: undefined })
+            
+            await sendNode(reply)
+        }
+        
         catch (error) {
-            logger.info({ trace: error.stack }, 'error in pairing');
-            end(error);
+            logger.info({ trace: error.stack }, 'error in pairing')
+            end(error)
         }
-    });
+    })
+    
     // login complete
     ws.on('CB:success', async (node) => {
         try {
-            await uploadPreKeysToServerIfRequired();
-            await sendPassiveIq('active');
-        }
+            await uploadPreKeysToServerIfRequired()
+            
+            await sendPassiveIq('active')
+            
+            logger.info('opened connection to WA')
+            
+            clearTimeout(qrTimer) // will never happen in all likelyhood -- but just in case WA sends success on first try
+            ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } })
+            ev.emit('connection.update', { connection: 'open' })
+        }
+        
         catch (err) {
-            logger.warn({ err }, 'failed to send initial passive iq');
-        }
-        logger.info('opened connection to WA');
-        clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
-        ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
-        ev.emit('connection.update', { connection: 'open' });
-        if (node.attrs.lid && authState.creds.me?.id) {
-            const myLID = node.attrs.lid;
-            process.nextTick(async () => {
-                try {
-                    const myPN = authState.creds.me.id;
-                    // Store our own LID-PN mapping
-                    await signalRepository.lidMapping.storeLIDPNMappings([{ lid: myLID, pn: myPN }]);
-                    // Create device list for our own user (needed for bulk migration)
-                    const { user, device } = jidDecode(myPN);
-                    await authState.keys.set({
-                        'device-list': {
-                            [user]: [device?.toString() || '0']
-                        }
-                    });
-                    // migrate our own session
-                    await signalRepository.migrateSession(myPN, myLID);
-                    logger.info({ myPN, myLID }, 'Own LID session created successfully');
-                }
-                catch (error) {
-                    logger.error({ error, lid: myLID }, 'Failed to create own LID session');
-                }
-            });
+            logger.error({ err }, 'error opening connection')
+            end(err)
         }
-    });
+    })
+    
     ws.on('CB:stream:error', (node) => {
-        logger.error({ node }, 'stream errored out');
-        const { reason, statusCode } = getErrorCodeFromStreamError(node);
-        end(new Boom(`Stream Errored (${reason})`, { statusCode, data: node }));
-    });
+        logger.error({ node }, 'stream errored out')
+        const { reason, statusCode } = Utils_1.getErrorCodeFromStreamError(node)
+        
+        end(new boom_1.Boom(`Stream Errored (${reason})`, { statusCode, data: node }))
+    })
+    
     // stream fail, possible logout
     ws.on('CB:failure', (node) => {
-        const reason = +(node.attrs.reason || 500);
-        end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
-    });
+        const reason = +(node.attrs.reason || 500)
+        
+        end(new boom_1.Boom('Connection Failure', { statusCode: reason, data: node.attrs }))
+    })
+    
     ws.on('CB:ib,,downgrade_webclient', () => {
-        end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
-    });
+        end(new boom_1.Boom('Multi-device beta not joined', { statusCode: Types_1.DisconnectReason.multideviceMismatch }))
+    })
+    
     ws.on('CB:ib,,offline_preview', (node) => {
-        logger.info('offline preview received', JSON.stringify(node));
+        logger.info('offline preview received', JSON.stringify(node))
+        
         sendNode({
             tag: 'ib',
             attrs: {},
             content: [{ tag: 'offline_batch', attrs: { count: '100' } }]
-        });
-    });
+        })
+    })
+    
     ws.on('CB:ib,,edge_routing', (node) => {
-        const edgeRoutingNode = getBinaryNodeChild(node, 'edge_routing');
-        const routingInfo = getBinaryNodeChild(edgeRoutingNode, 'routing_info');
+        const edgeRoutingNode = WABinary_1.getBinaryNodeChild(node, 'edge_routing')
+        const routingInfo = WABinary_1.getBinaryNodeChild(edgeRoutingNode, 'routing_info')
+        
         if (routingInfo?.content) {
-            authState.creds.routingInfo = Buffer.from(routingInfo?.content);
-            ev.emit('creds.update', authState.creds);
+            authState.creds.routingInfo = Buffer.from(routingInfo?.content)
+            ev.emit('creds.update', authState.creds)
         }
-    });
-    let didStartBuffer = false;
+    })
+    
+    let didStartBuffer = false
+    
     process.nextTick(() => {
         if (creds.me?.id) {
             // start buffering important events
             // if we're logged in
-            ev.buffer();
-            didStartBuffer = true;
+            ev.buffer()
+            didStartBuffer = true
         }
-        ev.emit('connection.update', { connection: 'connecting', receivedPendingNotifications: false, qr: undefined });
-    });
+        
+        ev.emit('connection.update', { connection: 'connecting', receivedPendingNotifications: false, qr: undefined })
+    })
+    
     // called when all offline notifs are handled
     ws.on('CB:ib,,offline', (node) => {
-        const child = getBinaryNodeChild(node, 'offline');
-        const offlineNotifs = +(child?.attrs.count || 0);
-        logger.info(`handled ${offlineNotifs} offline messages/notifications`);
+        const child = WABinary_1.getBinaryNodeChild(node, 'offline')
+        const offlineNotifs = +(child?.attrs.count || 0)
+        
+        logger.info(`handled ${offlineNotifs} offline messages/notifications`)
+        
         if (didStartBuffer) {
-            ev.flush();
-            logger.trace('flushed events for initial buffer');
+            ev.flush()
+            logger.trace('flushed events for initial buffer')
         }
-        ev.emit('connection.update', { receivedPendingNotifications: true });
-    });
+        
+        ev.emit('connection.update', { receivedPendingNotifications: true })
+    })
+    
     // update credentials when required
     ev.on('creds.update', update => {
-        const name = update.me?.name;
+        const name = update.me?.name
+        
         // if name has just been received
         if (creds.me?.name !== name) {
-            logger.debug({ name }, 'updated pushName');
+            logger.debug({ name }, 'updated pushName')
+            
             sendNode({
                 tag: 'presence',
-                attrs: { name: name }
+                attrs: { name }
             }).catch(err => {
-                logger.warn({ trace: err.stack }, 'error in sending presence update on name change');
-            });
-        }
-        Object.assign(creds, update);
-    });
+                logger.warn({ trace: err.stack }, 'error in sending presence update on name change')
+            })
+        }
+        
+        Object.assign(creds, update)
+    })
+    
+    if (printQRInTerminal) {
+        Utils_1.printQRIfNecessaryListener(ev, logger)
+    }
+    
     return {
         type: 'md',
         ws,
@@ -830,7 +731,7 @@ if (config.printQRInTerminal) {
         authState: { creds, keys },
         signalRepository,
         get user() {
-            return authState.creds.me;
+            return authState.creds.me
         },
         generateMessageTag,
         query,
@@ -844,21 +745,22 @@ if (config.printQRInTerminal) {
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,
         requestPairingCode,
-        wamBuffer: publicWAMBuffer,
         /** Waits for the connection to WA to reach a state */
-        waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
+        waitForConnectionUpdate: Utils_1.bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
-        executeUSyncQuery,
-        onWhatsApp
-    };
-};
+    }
+}
+
 /**
  * map the websocket error to the right type
  * so it can be retried by the caller
  * */
 function mapWebSocketError(handler) {
     return (error) => {
-        handler(new Boom(`WebSocket Error (${error?.message})`, { statusCode: getCodeFromWSError(error), data: error }));
-    };
+        handler(new boom_1.Boom(`WebSocket Error (${error?.message})`, { statusCode: Utils_1.getCodeFromWSError(error), data: error }))
+    }
 }
-//# sourceMappingURL=socket.js.map
+
+module.exports = {
+  makeSocket
+}