@badzz88/baileys 8.5.6 → 8.5.8

package/{src → lib}/Socket/socket.js

@@ -1,56 +1,66 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.makeSocket = void 0;
-const boom_1 = require('@hapi/boom');
-const crypto_1 = require('crypto');
-const url_1 = require('url');
-const util_1 = require('util');
-const index_js_1 = require('../../WAProto/index.js');
-const Defaults_1 = require('../Defaults');
-const Types_1 = require('../Types');
-const Utils_1 = require('../Utils');
-const browser_utils_1 = require('../Utils/browser-utils');
-const WABinary_1 = require('../WABinary');
-const BinaryInfo_js_1 = require('../WAM/BinaryInfo.js');
-const WAUSync_1 = require('../WAUSync/');
-const Client_1 = require('./Client');
-const mex_1 = require('./mex');
-const makeSocket = config => {
+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, NOISE_WA_HEADER, PROCESSABLE_HISTORY_TYPES, TimeMs, UPLOAD_TIMEOUT } from '../Defaults/index.js';
+import { QueryIds, ReachoutTimelockEnforcementType } from '../Types/index.js';
+import { DisconnectReason, XWAPaths } from '../Types/index.js';
+import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, buildPairingQRData, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getCompanionPlatformId, getErrorCodeFromStreamError, getNextPreKeysNode, makeEventBuffer, makeNoiseHandler, promiseTimeout, signedKeyPair, xmppSignedPreKey } from '../Utils/index.js';
+import { assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getAllBinaryNodeChildren, 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';
+import { executeWMexQuery } from './mex.js';
+/**
+ * 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_js_1.BinaryInfo();
+    const publicWAMBuffer = new BinaryInfo();
     let serverTimeOffsetMs = 0;
-    const uqTagId = (0, Utils_1.generateMdTagPrefix)();
-    const generateMessageTag = () => `${uqTagId}${epoch++}`;
+    const uqTagId = generateMdTagPrefix();
+    const generateMessageTag = () => `VINNXSYNC-${epoch++}`;
+    if (browser[1].toLocaleLowerCase().includes('android')) {
+        logger.warn('⚠️ Using the Android browser is experimental and may lead to unexpected behavior. Use at your own risk.');
+    }
     if (printQRInTerminal) {
         logger.warn({}, '⚠️ The printQRInTerminal option has been deprecated. You will no longer receive QR codes in the terminal automatically. Please listen to the connection.update event yourself and handle the QR your way. You can remove this message by removing this opttion. This message will be removed in a future version.');
     }
-    const syncDisabled = Defaults_1.PROCESSABLE_HISTORY_TYPES.map(syncType => config.shouldSyncHistoryMessage({ syncType })).filter(x => x === false).length === Defaults_1.PROCESSABLE_HISTORY_TYPES.length;
+    const syncDisabled = PROCESSABLE_HISTORY_TYPES.map(syncType => config.shouldSyncHistoryMessage({ syncType })).filter(x => x === false)
+        .length === PROCESSABLE_HISTORY_TYPES.length;
     if (syncDisabled) {
         logger.warn('⚠️ DANGER: DISABLING ALL SYNC BY shouldSyncHistoryMsg PREVENTS BAILEYS FROM ACCESSING INITIAL LID MAPPINGS, LEADING TO INSTABILIY AND SESSION ERRORS');
     }
-    const url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
+    const url = typeof waWebSocketUrl === 'string' ? new URL(waWebSocketUrl) : waWebSocketUrl;
     if (config.mobile || url.protocol === 'tcp:') {
-        throw new boom_1.Boom('Mobile API is not supported anymore', { statusCode: Types_1.DisconnectReason.loggedOut });
+        throw new Boom('Mobile API is not supported anymore', { statusCode: DisconnectReason.loggedOut });
     }
     if (url.protocol === 'wss' && authState?.creds?.routingInfo) {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
-    const ephemeralKeyPair = Utils_1.Curve.generateKeyPair();
-    const noise = (0, Utils_1.makeNoiseHandler)({
+    /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
+    const ephemeralKeyPair = Curve.generateKeyPair();
+    /** WA noise protocol wrapper */
+    const noise = makeNoiseHandler({
         keyPair: ephemeralKeyPair,
-        NOISE_HEADER: Defaults_1.NOISE_WA_HEADER,
+        NOISE_HEADER: NOISE_WA_HEADER,
         logger,
         routingInfo: authState?.creds?.routingInfo
     });
-    const ws = new Client_1.WebSocketClient(url, config);
+    const ws = new WebSocketClient(url, config);
     ws.connect();
-    const sendPromise = (0, util_1.promisify)(ws.send);
+    const sendPromise = promisify(ws.send);
+    /** send a raw buffer */
     const sendRawMessage = async (data) => {
         if (!ws.isOpen) {
-            throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed });
+            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
         }
         const bytes = noise.encodeFrame(data);
-        await (0, Utils_1.promiseTimeout)(connectTimeoutMs, async (resolve, reject) => {
+        await promiseTimeout(connectTimeoutMs, async (resolve, reject) => {
             try {
                 await sendPromise.call(ws, bytes);
                 resolve();
@@ -60,36 +70,43 @@ const makeSocket = config => {
             }
         });
     };
-    const sendNode = frame => {
+    /** send a binary node */
+    const sendNode = (frame) => {
         if (logger.level === 'trace') {
-            logger.trace({ xml: (0, WABinary_1.binaryNodeToString)(frame), msg: 'xml send' });
+            logger.trace({ xml: binaryNodeToString(frame), msg: 'xml send' });
         }
-        const buff = (0, WABinary_1.encodeBinaryNode)(frame);
+        const buff = encodeBinaryNode(frame);
         return sendRawMessage(buff);
     };
+    /**
+     * 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;
         try {
-            const result = await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
+            const result = await promiseTimeout(timeoutMs, (resolve, reject) => {
                 onRecv = data => {
                     resolve(data);
                 };
                 onErr = err => {
                     reject(err ||
-                        new boom_1.Boom('Connection Closed', {
-                            statusCode: Types_1.DisconnectReason.connectionClosed
+                        new Boom('Connection Closed', {
+                            statusCode: DisconnectReason.connectionClosed
                         }));
                 };
                 ws.on(`TAG:${msgId}`, onRecv);
                 ws.on('close', onErr);
                 ws.on('error', onErr);
-                return () => reject(new boom_1.Boom('Query Cancelled'));
+                return () => reject(new Boom('Query Cancelled'));
             });
             return result;
         }
         catch (error) {
-            if (error instanceof boom_1.Boom && error.output?.statusCode === Types_1.DisconnectReason.timedOut) {
+            // 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;
             }
@@ -104,55 +121,60 @@ const makeSocket = config => {
             }
         }
     };
+    /** 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 (0, Utils_1.promiseTimeout)(timeoutMs, async (resolve, reject) => {
+        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) {
-            ;
-            (0, WABinary_1.assertNodeErrorFree)(result);
+            assertNodeErrorFree(result);
         }
         return result;
     };
+    // Validate current key-bundle on server; on failure, trigger pre-key upload and rethrow
     const digestKeyBundle = async () => {
         const res = await query({
             tag: 'iq',
-            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: 'get', xmlns: 'encrypt' },
+            attrs: { to: S_WHATSAPP_NET, type: 'get', xmlns: 'encrypt' },
             content: [{ tag: 'digest', attrs: {} }]
         });
-        const digestNode = (0, WABinary_1.getBinaryNodeChild)(res, 'digest');
+        const digestNode = getBinaryNodeChild(res, 'digest');
         if (!digestNode) {
             await uploadPreKeys();
             throw new Error('encrypt/get digest returned no digest node');
         }
     };
+    // Rotate our signed pre-key on server; on failure, run digest as fallback and rethrow
     const rotateSignedPreKey = async () => {
         const newId = (creds.signedPreKey.keyId || 0) + 1;
-        const skey = await (0, Utils_1.signedKeyPair)(creds.signedIdentityKey, newId);
+        const skey = await signedKeyPair(creds.signedIdentityKey, newId);
         await query({
             tag: 'iq',
-            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: 'set', xmlns: 'encrypt' },
+            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'encrypt' },
             content: [
                 {
                     tag: 'rotate',
                     attrs: {},
-                    content: [(0, Utils_1.xmppSignedPreKey)(skey)]
+                    content: [xmppSignedPreKey(skey)]
                 }
             ]
         });
+        // Persist new signed pre-key in creds
         ev.emit('creds.update', { signedPreKey: skey });
     };
     const executeUSyncQuery = async (usyncQuery) => {
         if (usyncQuery.protocols.length === 0) {
-            throw new boom_1.Boom('USyncQuery must have at least one protocol');
+            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 {
@@ -176,7 +198,7 @@ const makeSocket = config => {
         const iq = {
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'get',
                 xmlns: 'usync'
             },
@@ -197,44 +219,75 @@ const makeSocket = config => {
         const result = await query(iq);
         return usyncQuery.parseUSyncQueryResult(result);
     };
-    const onWhatsApp = async (...phoneNumber) => {
-        let usyncQuery = new WAUSync_1.USyncQuery();
-        let contactEnabled = false;
-        for (const jid of phoneNumber) {
-            if ((0, WABinary_1.isLidUser)(jid)) {
+    const buildAllProtocolsQuery = () => new USyncQuery()
+        .withContactProtocol()
+        .withLIDProtocol()
+        .withDeviceProtocol()
+        .withStatusProtocol()
+        .withDisappearingModeProtocol()
+        .withBotProfileProtocol()
+        .withUsernameProtocol()
+        .withBusinessProtocol()
+        .withPictureProtocol()
+        .withTextStatusProtocol()
+        .withSidelistProtocol()
+        .withFeatureProtocol();
+    const onWhatsApp = async (...pn) => {
+        const usyncQuery = buildAllProtocolsQuery();
+        for (const jid of pn) {
+            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 WAUSync_1.USyncUser().withPhone(phone));
-            }
+            const phone = `+${jid.replace('+', '').split('@')[0]?.split(':')[0]}`;
+            usyncQuery.withUser(new USyncUser().withPhone(phone));
         }
         if (usyncQuery.users.length === 0) {
-            return [];
+            return []; // return early without forcing an empty query
+        }
+        let results;
+        try {
+            results = await executeUSyncQuery(usyncQuery);
+        }
+        catch (err) {
+            logger?.warn({ err }, 'onWhatsApp: full usync query failed, retrying with contact+lid protocols only');
+            const fallbackQuery = new USyncQuery().withContactProtocol().withLIDProtocol();
+            fallbackQuery.users = usyncQuery.users;
+            results = await executeUSyncQuery(fallbackQuery);
         }
-        const results = await executeUSyncQuery(usyncQuery);
         if (results) {
-            return results.list.filter(a => !!a.contact).map(({ contact, id }) => ({ jid: id, exists: contact }));
+            return results.list
+                .filter(a => !!a.contact)
+                .map(({ contact, id, lid, devices, status, disappearing_mode, bot, username, business, picture, text_status, sidelist, feature }) => ({
+                    jid: id,
+                    exists: contact,
+                    lid: lid ?? null,
+                    devices: devices ?? null,
+                    status: status ?? null,
+                    disappearingMode: disappearing_mode ?? null,
+                    bot: bot ?? null,
+                    username: username ?? null,
+                    business: business ?? null,
+                    picture: picture ?? null,
+                    textStatus: text_status ?? null,
+                    sidelist: sidelist ?? null,
+                    feature: feature ?? null
+                }));
         }
     };
     const pnFromLIDUSync = async (jids) => {
-        const usyncQuery = new WAUSync_1.USyncQuery().withLIDProtocol().withContext('background');
+        const usyncQuery = new USyncQuery().withLIDProtocol().withContext('background');
         for (const jid of jids) {
-            if ((0, WABinary_1.isLidUser)(jid)) {
+            if (isLidUser(jid)) {
                 logger?.warn('LID user found in LID fetch call');
                 continue;
             }
             else {
-                usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid));
+                usyncQuery.withUser(new USyncUser().withId(jid));
             }
         }
         if (usyncQuery.users.length === 0) {
-            return [];
+            return []; // return early without forcing an empty query
         }
         const results = await executeUSyncQuery(usyncQuery);
         if (results) {
@@ -242,76 +295,99 @@ const makeSocket = config => {
         }
         return [];
     };
-    const toPn = async (lid) => {
-        const lids = Array.isArray(lid) ? lid : [lid];
-        const usyncQuery = new WAUSync_1.USyncQuery().withContactProtocol().withLIDProtocol();
-        for (const l of lids) {
-            const decoded = (0, WABinary_1.jidDecode)(l);
-            if (!decoded)
-                continue;
-            usyncQuery.withUser(new WAUSync_1.USyncUser().withId((0, WABinary_1.jidEncode)(decoded.user, 's.whatsapp.net')).withLid(l));
-        }
-        const result = await executeUSyncQuery(usyncQuery);
-        return lids.map(l => {
-            const decoded = (0, WABinary_1.jidDecode)(l);
-            if (!decoded)
-                return { lid: l, pn: null };
-            const match = result?.list?.find(entry => {
-                const entryDecoded = (0, WABinary_1.jidDecode)(entry.id);
-                return entryDecoded?.user === decoded.user;
-            });
-            if (!match?.contact)
-                return { lid: l, pn: null };
-            const pn = (0, WABinary_1.jidEncode)((0, WABinary_1.jidDecode)(match.id)?.user, 's.whatsapp.net');
-            return { lid: l, pn: pn ?? null };
-        });
-    };
-    const toLID = async (pn) => {
-        const pns = Array.isArray(pn) ? pn : [pn];
-        const usyncQuery = new WAUSync_1.USyncQuery().withContactProtocol().withLIDProtocol();
-        for (const p of pns) {
-            const decoded = (0, WABinary_1.jidDecode)(p);
-            if (!decoded)
-                continue;
-            usyncQuery.withUser(new WAUSync_1.USyncUser().withId((0, WABinary_1.jidEncode)(decoded.user, 's.whatsapp.net')));
-        }
-        const result = await executeUSyncQuery(usyncQuery);
-        return pns.map(p => {
-            const decoded = (0, WABinary_1.jidDecode)(p);
-            if (!decoded)
-                return { pn: p, lid: null };
-            const match = result?.list?.find(entry => {
-                return (0, WABinary_1.jidDecode)(entry.id)?.user === decoded.user;
-            });
-            if (!match?.contact)
-                return { pn: p, lid: null };
-            const lidVal = match?.lid ?? null;
-            const lid = lidVal ? (0, WABinary_1.jidEncode)((0, WABinary_1.jidDecode)(lidVal)?.user ?? lidVal, 'lid') : null;
-            return { pn: p, lid };
-        });
-    };
-    const fetchUsername = async (username, pin) => {
-        const usernames = Array.isArray(username) ? username : [username];
-        const usyncQuery = new WAUSync_1.USyncQuery().withContactProtocol().withLIDProtocol();
-        for (const u of usernames) {
-            const user = new WAUSync_1.USyncUser().withUsername(u);
-            if (pin)
-                user.withUsernameKey(pin);
-            usyncQuery.withUser(user);
-        }
-        const result = await executeUSyncQuery(usyncQuery);
-        return usernames.map(u => {
-            const match = result?.list?.find(entry => entry?.username === u);
-            if (!match?.contact)
-                return { username: u, pn: null, lid: null };
-            const lid = match.lid;
-            const pn = (0, WABinary_1.jidEncode)((0, WABinary_1.jidDecode)(match.id)?.user, 's.whatsapp.net');
-            return { username: u, pn: pn ?? null, lid: lid ?? null };
-        });
-    };
-    const ev = (0, Utils_1.makeEventBuffer)(logger);
+	/**
+	 * @param {string | string[]} lid - @lid JID or array of @lid JID
+	 * @returns {Promise<{ lid: string, pn: string | null }[]>}
+	 */
+	const toPn = async lid => {
+		const lids = Array.isArray(lid) ? lid : [lid]
+		const usyncQuery = new USyncQuery()
+			.withContactProtocol()
+			.withLIDProtocol()
+		for (const l of lids) {
+			const decoded = jidDecode(l)
+			if (!decoded) continue
+			usyncQuery.withUser(
+				new USyncUser()
+					.withId(jidEncode(decoded.user, 's.whatsapp.net'))
+					.withLid(l)
+			)
+		}
+		const result = await executeUSyncQuery(usyncQuery)
+		return lids.map(l => {
+			const decoded = jidDecode(l)
+			if (!decoded) return { lid: l, pn: null }
+
+			const match = result?.list?.find(entry => {
+				const entryDecoded = jidDecode(entry.id)
+				return entryDecoded?.user === decoded.user
+			})
+
+			if (!match?.contact) return { lid: l, pn: null }
+
+			const pn = jidEncode(jidDecode(match.id)?.user, 's.whatsapp.net')
+			return { lid: l, pn: pn ?? null }
+		})
+	}
+	/**
+	 * @param {string | string[]} s.whatsapp.net - @s.whatsapp.net JID or array of @s.whatsapp.net JID
+	 * @returns {Promise<{ pn: string, lid: string | null }[]>}
+	 */
+	const toLID = async pn => {
+		const pns = Array.isArray(pn) ? pn : [pn]
+		const usyncQuery = new USyncQuery()
+			.withContactProtocol()
+			.withLIDProtocol()
+		for (const p of pns) {
+			const decoded = jidDecode(p)
+			if (!decoded) continue
+			usyncQuery.withUser(
+				new USyncUser().withId(jidEncode(decoded.user, 's.whatsapp.net'))
+			)
+		}
+		const result = await executeUSyncQuery(usyncQuery)
+		return pns.map(p => {
+			const decoded = jidDecode(p)
+			if (!decoded) return { pn: p, lid: null }
+
+			const match = result?.list?.find(entry => {
+				return jidDecode(entry.id)?.user === decoded.user
+			})
+
+			if (!match?.contact) return { pn: p, lid: null }
+
+			const lidVal = match?.lid ?? null
+			const lid = lidVal ? jidEncode(jidDecode(lidVal)?.user ?? lidVal, 'lid') : null
+			return { pn: p, lid }
+		})
+	}
+	/**
+	 * @param {string, pin} username - username to fetch, pin - pin of username if da user enable it
+	 * @returns {Promise<{ username: string, pn: string | null, lid: string | null }[]>}
+	 */
+	const fetchUsername = async (username, pin) => {
+		const usernames = Array.isArray(username) ? username : [username]
+		const usyncQuery = new USyncQuery()
+		    .withContactProtocol()
+		    .withLIDProtocol()
+		for (const u of usernames) {
+			const user = new USyncUser().withUsername(u)
+			if (pin) user.withUsernameKey(pin)
+			usyncQuery.withUser(user)
+		}
+		const result = await executeUSyncQuery(usyncQuery)
+		return usernames.map(u => {
+			const match = result?.list?.find(entry => entry?.username === u)
+			if (!match?.contact) return { username: u, pn: null, lid: null }
+			const lid = match.lid;
+			const pn = jidEncode(jidDecode(match.id)?.user, 's.whatsapp.net')
+			return { username: u, pn: pn ?? null, lid: lid ?? null }
+		})
+	}
+    const ev = makeEventBuffer(logger);
     const { creds } = authState;
-    const keys = (0, Utils_1.addTransactionCapability)(authState.keys, logger, transactionOpts);
+    // add transaction capability
+    const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
     const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync);
     let lastDateRecv;
     let epoch = 1;
@@ -319,18 +395,20 @@ const makeSocket = config => {
     let qrTimer;
     let closed = false;
     const socketEndHandlers = [];
+    /** 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
+            throw new Boom('Connection Closed', {
+                statusCode: DisconnectReason.connectionClosed
             });
         }
         let onOpen;
         let onClose;
-        const result = (0, Utils_1.promiseTimeout)(connectTimeoutMs, (resolve, reject) => {
+        const result = promiseTimeout(connectTimeoutMs, (resolve, reject) => {
             onOpen = resolve;
             onClose = mapWebSocketError(reject);
             ws.on('frame', onOpen);
@@ -346,28 +424,29 @@ const makeSocket = config => {
         }
         return result;
     };
+    /** connection handshake */
     const validateConnection = async () => {
         let helloMsg = {
             clientHello: { ephemeral: ephemeralKeyPair.public }
         };
-        helloMsg = index_js_1.proto.HandshakeMessage.fromObject(helloMsg);
+        helloMsg = proto.HandshakeMessage.fromObject(helloMsg);
         logger.info({ browser, helloMsg }, 'connected to WA');
-        const init = index_js_1.proto.HandshakeMessage.encode(helloMsg).finish();
+        const init = proto.HandshakeMessage.encode(helloMsg).finish();
         const result = await awaitNextMessage(init);
-        const handshake = index_js_1.proto.HandshakeMessage.decode(result);
+        const handshake = proto.HandshakeMessage.decode(result);
         logger.trace({ handshake }, 'handshake recv from WA');
         const keyEnc = noise.processHandshake(handshake, creds.noiseKey);
         let node;
         if (!creds.me) {
-            node = (0, Utils_1.generateRegistrationNode)(creds, config);
+            node = generateRegistrationNode(creds, config);
             logger.info({ node }, 'not logged in, attempting registration...');
         }
         else {
-            node = (0, Utils_1.generateLoginNode)(creds.me.id, config, creds);
+            node = generateLoginNode(creds.me.id, config);
             logger.info({ node }, 'logging in...');
         }
-        const payloadEnc = noise.encrypt(index_js_1.proto.ClientPayload.encode(node).finish());
-        await sendRawMessage(index_js_1.proto.HandshakeMessage.encode({
+        const payloadEnc = noise.encrypt(proto.ClientPayload.encode(node).finish());
+        await sendRawMessage(proto.HandshakeMessage.encode({
             clientFinish: {
                 static: keyEnc,
                 payload: payloadEnc
@@ -383,54 +462,53 @@ const makeSocket = config => {
                 id: generateMessageTag(),
                 xmlns: 'encrypt',
                 type: 'get',
-                to: WABinary_1.S_WHATSAPP_NET
+                to: S_WHATSAPP_NET
             },
             content: [{ tag: 'count', attrs: {} }]
         });
-        const countChild = (0, WABinary_1.getBinaryNodeChild)(result, 'count');
+        const countChild = getBinaryNodeChild(result, 'count');
         return +countChild.attrs.value;
     };
+    // WAWeb has no time throttle here; the server drives uploads via PreKeyLow notifications.
     let uploadPreKeysPromise = null;
-    let lastUploadTime = 0;
-    const uploadPreKeys = async (count = Defaults_1.MIN_PREKEY_COUNT, retryCount = 0) => {
-        if (retryCount === 0) {
-            const timeSinceLastUpload = Date.now() - lastUploadTime;
-            if (timeSinceLastUpload < Defaults_1.MIN_UPLOAD_INTERVAL) {
-                logger.debug(`Skipping upload, only ${timeSinceLastUpload}ms since last upload`);
-                return;
-            }
-        }
+    /** generates and uploads a set of pre-keys to the server */
+    const uploadPreKeys = async (count = MIN_PREKEY_COUNT) => {
         if (uploadPreKeysPromise) {
             logger.debug('Pre-key upload already in progress, waiting for completion');
             await uploadPreKeysPromise;
+            return;
         }
-        const uploadLogic = async () => {
+        const uploadLogic = async (retryCount) => {
             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 (0, Utils_1.getNextPreKeysNode)({ creds, keys }, 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;
             }, 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');
+                // Recurse into uploadLogic; calling uploadPreKeys would await its own in-flight promise.
                 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);
+                    return uploadLogic(retryCount + 1);
                 }
                 throw uploadError;
             }
         };
+        // Add timeout protection
         uploadPreKeysPromise = Promise.race([
-            uploadLogic(),
-            new Promise((_, reject) => setTimeout(() => reject(new boom_1.Boom('Pre-key upload timeout', { statusCode: 408 })), Defaults_1.UPLOAD_TIMEOUT))
+            uploadLogic(0),
+            new Promise((_, reject) => setTimeout(() => reject(new Boom('Pre-key upload timeout', { statusCode: 408 })), UPLOAD_TIMEOUT))
         ]);
         try {
             await uploadPreKeysPromise;
@@ -453,9 +531,9 @@ const makeSocket = config => {
             let count = 0;
             const preKeyCount = await getAvailablePreKeysOnServer();
             if (preKeyCount === 0)
-                count = Defaults_1.INITIAL_PREKEY_COUNT;
+                count = INITIAL_PREKEY_COUNT;
             else
-                count = Defaults_1.MIN_PREKEY_COUNT;
+                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}`);
@@ -477,30 +555,34 @@ const makeSocket = config => {
         }
         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 onMessageReceived = async (data) => {
         await noise.decodeFrame(data, frame => {
+            // reset ping timeout
             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;
                 if (logger.level === 'trace') {
-                    logger.trace({ xml: (0, WABinary_1.binaryNodeToString)(frame), msg: 'recv xml' });
+                    logger.trace({ xml: binaryNodeToString(frame), msg: 'recv xml' });
                 }
-                anyTriggered = ws.emit(`${Defaults_1.DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered;
+                /* Check if this is a response to a message we sent */
+                anyTriggered = ws.emit(`${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 : '';
                 for (const key of Object.keys(l1)) {
-                    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},${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},,${l2}`, frame) || anyTriggered;
-                anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
+                anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered;
+                anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
                 if (!anyTriggered && logger.level === 'debug') {
                     logger.debug({ unhandled: true, msgId, fromMe: false, frame }, 'communication recv');
                 }
@@ -519,6 +601,7 @@ const makeSocket = config => {
         ws.removeAllListeners('close');
         ws.removeAllListeners('open');
         ws.removeAllListeners('message');
+        signalRepository.close?.();
         if (!ws.isClosed && !ws.isClosing) {
             try {
                 await ws.close();
@@ -541,13 +624,14 @@ const makeSocket = config => {
             }
         });
         ev.removeAllListeners('connection.update');
+        ev.destroy();
     };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
             return;
         }
         if (ws.isClosed || ws.isClosing) {
-            throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed });
+            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
         }
         let onOpen;
         let onClose;
@@ -568,15 +652,20 @@ const makeSocket = config => {
             lastDateRecv = new Date();
         }
         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) {
-            void end(new boom_1.Boom('Connection was lost', { statusCode: Types_1.DisconnectReason.connectionLost }));
+            void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
         }
         else if (ws.isOpen) {
+            // if its all good, send a keep alive request
             query({
                 tag: 'iq',
                 attrs: {
                     id: generateMessageTag(),
-                    to: WABinary_1.S_WHATSAPP_NET,
+                    to: S_WHATSAPP_NET,
                     type: 'get',
                     xmlns: 'w:p'
                 },
@@ -589,22 +678,24 @@ const makeSocket = config => {
             logger.warn('keep alive called when WS not open');
         }
     }, keepAliveIntervalMs));
-    const sendPassiveIq = tag => query({
+    /** i have no idea why this exists. pls enlighten me */
+    const sendPassiveIq = (tag) => query({
         tag: 'iq',
         attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: S_WHATSAPP_NET,
             xmlns: 'passive',
             type: 'set'
         },
         content: [{ tag, attrs: {} }]
     });
+    /** logout & invalidate connection */
     const logout = async (msg) => {
         const jid = authState.creds.me?.id;
         if (jid) {
             await sendNode({
                 tag: 'iq',
                 attrs: {
-                    to: WABinary_1.S_WHATSAPP_NET,
+                    to: S_WHATSAPP_NET,
                     type: 'set',
                     id: generateMessageTag(),
                     xmlns: 'md'
@@ -620,23 +711,25 @@ const makeSocket = config => {
                 ]
             });
         }
-        void end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }));
+        void end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
-    const requestPairingCode = async (phoneNumber, customPairingCode) => {
-        const pairingCode = customPairingCode ?? (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
-        if (customPairingCode && customPairingCode?.length !== 8) {
+
+    const requestPairingCode = async (phoneNumber, customPairingCode = 'VINXSYNC') => {
+        const pairingCode = customPairingCode;
+        if (pairingCode && pairingCode.length !== 8) {
             throw new Error('Custom pairing code must be exactly 8 chars');
         }
+
         authState.creds.pairingCode = pairingCode;
         authState.creds.me = {
-            id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
+            id: jidEncode(phoneNumber, 's.whatsapp.net'),
             name: '~'
         };
         ev.emit('creds.update', authState.creds);
         await sendNode({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 id: generateMessageTag(),
                 xmlns: 'md'
@@ -663,7 +756,7 @@ const makeSocket = config => {
                         {
                             tag: 'companion_platform_id',
                             attrs: {},
-                            content: (0, browser_utils_1.getPlatformId)(browser[1])
+                            content: getCompanionPlatformId(browser)
                         },
                         {
                             tag: 'companion_platform_display',
@@ -682,17 +775,17 @@ const makeSocket = config => {
         return authState.creds.pairingCode;
     };
     async function generatePairingKey() {
-        const salt = (0, crypto_1.randomBytes)(32);
-        const randomIv = (0, crypto_1.randomBytes)(16);
-        const key = await (0, Utils_1.derivePairingCodeKey)(authState.creds.pairingCode, salt);
-        const ciphered = (0, Utils_1.aesEncryptCTR)(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
+        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 sendWAMBuffer = wamBuffer => {
+    const sendWAMBuffer = (wamBuffer) => {
         return query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 id: generateMessageTag(),
                 xmlns: 'w:stats'
             },
@@ -716,46 +809,50 @@ const makeSocket = config => {
         }
     });
     ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => void end(new boom_1.Boom('Connection Terminated', { statusCode: Types_1.DisconnectReason.connectionClosed })));
-    ws.on('CB:xmlstreamend', () => void end(new boom_1.Boom('Connection Terminated by Server', { statusCode: Types_1.DisconnectReason.connectionClosed })));
+    ws.on('close', () => void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+    // the server terminated the connection
+    ws.on('CB:xmlstreamend', () => void end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
+    // QR gen
     ws.on('CB:iq,type:set,pair-device', async (stanza) => {
         const iq = {
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'result',
                 id: stanza.attrs.id
             }
         };
         await sendNode(iq);
-        const pairDeviceNode = (0, WABinary_1.getBinaryNodeChild)(stanza, 'pair-device');
-        const refNodes = (0, WABinary_1.getBinaryNodeChildren)(pairDeviceNode, 'ref');
+        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;
+        let qrMs = qrTimeout || 60000; // time to let a QR live
         const genPairQR = () => {
             if (!ws.isOpen) {
                 return;
             }
             const refNode = refNodes.shift();
             if (!refNode) {
-                void end(new boom_1.Boom('QR refs attempts ended', { statusCode: Types_1.DisconnectReason.timedOut }));
+                void end(new Boom('QR refs attempts ended', { statusCode: DisconnectReason.timedOut }));
                 return;
             }
             const ref = refNode.content.toString('utf-8');
-            const qr = [ref, noiseKeyB64, identityKeyB64, advB64].join(',');
+            const qr = buildPairingQRData(ref, noiseKeyB64, identityKeyB64, advB64, browser);
             ev.emit('connection.update', { qr });
             qrTimer = setTimeout(genPairQR, qrMs);
-            qrMs = qrTimeout || 20000;
+            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');
         try {
             updateServerTimeOffset(stanza);
-            const { reply, creds: updatedCreds } = (0, Utils_1.configureSuccessfulPairing)(stanza, creds);
+            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 });
@@ -767,13 +864,13 @@ const makeSocket = config => {
             void end(error);
         }
     });
+    // login complete
     ws.on('CB:success', async (node) => {
         try {
             updateServerTimeOffset(node);
             await uploadPreKeysToServerIfRequired();
-            if (!config.masqueradeAsPrimary) {
-                await sendPassiveIq('active');
-            }
+            await sendPassiveIq('active');
+            // After successful login, validate our key-bundle against server
             try {
                 await digestKeyBundle();
             }
@@ -785,12 +882,8 @@ const makeSocket = config => {
             logger.warn({ err }, 'failed to send initial passive iq');
         }
         logger.info('opened connection to WA');
-        clearTimeout(qrTimer);
+        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 } });
-        if (config.syncFullHistory && authState.creds.initialFullSyncDone !== true) {
-            logger.debug('initial full history sync completed, persisting one-time flag');
-            ev.emit('creds.update', { initialFullSyncDone: true });
-        }
         ev.emit('connection.update', { connection: 'open' });
         void sendUnifiedSession();
         if (node.attrs.lid && authState.creds.me?.id) {
@@ -798,13 +891,16 @@ const makeSocket = config => {
             process.nextTick(async () => {
                 try {
                     const myPN = authState.creds.me.id;
+                    // Store our own LID-PN mapping
                     await signalRepository.lidMapping.storeLIDPNMappings([{ lid: myLID, pn: myPN }]);
-                    const { user, device } = (0, WABinary_1.jidDecode)(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');
                 }
@@ -814,18 +910,19 @@ const makeSocket = config => {
             });
         }
     });
-    ws.on('CB:stream:error', node => {
-        const [reasonNode] = (0, WABinary_1.getAllBinaryNodeChildren)(node);
+    ws.on('CB:stream:error', (node) => {
+        const [reasonNode] = getAllBinaryNodeChildren(node);
         logger.error({ reasonNode, fullErrorNode: node }, 'stream errored out');
-        const { reason, statusCode } = (0, Utils_1.getErrorCodeFromStreamError)(node);
-        void end(new boom_1.Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
+        const { reason, statusCode } = getErrorCodeFromStreamError(node);
+        void end(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
     });
-    ws.on('CB:failure', node => {
+    // stream fail, possible logout
+    ws.on('CB:failure', (node) => {
         const reason = +(node.attrs.reason || 500);
-        void end(new boom_1.Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
+        void end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
     });
     ws.on('CB:ib,,downgrade_webclient', () => {
-        void end(new boom_1.Boom('Multi-device beta not joined', { statusCode: Types_1.DisconnectReason.multideviceMismatch }));
+        void end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
     });
     ws.on('CB:ib,,offline_preview', async (node) => {
         logger.info('offline preview received', JSON.stringify(node));
@@ -835,9 +932,9 @@ const makeSocket = config => {
             content: [{ tag: 'offline_batch', attrs: { count: '100' } }]
         });
     });
-    ws.on('CB:ib,,edge_routing', node => {
-        const edgeRoutingNode = (0, WABinary_1.getBinaryNodeChild)(node, 'edge_routing');
-        const routingInfo = (0, WABinary_1.getBinaryNodeChild)(edgeRoutingNode, 'routing_info');
+    ws.on('CB:ib,,edge_routing', (node) => {
+        const edgeRoutingNode = getBinaryNodeChild(node, 'edge_routing');
+        const routingInfo = getBinaryNodeChild(edgeRoutingNode, 'routing_info');
         if (routingInfo?.content) {
             authState.creds.routingInfo = Buffer.from(routingInfo?.content);
             ev.emit('creds.update', authState.creds);
@@ -846,13 +943,16 @@ const makeSocket = config => {
     let didStartBuffer = false;
     process.nextTick(() => {
         if (creds.me?.id) {
+            // start buffering important events
+            // if we're logged in
             ev.buffer();
             didStartBuffer = true;
         }
         ev.emit('connection.update', { connection: 'connecting', receivedPendingNotifications: false, qr: undefined });
     });
-    ws.on('CB:ib,,offline', node => {
-        const child = (0, WABinary_1.getBinaryNodeChild)(node, 'offline');
+    // 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`);
         if (didStartBuffer) {
@@ -861,8 +961,10 @@ const makeSocket = config => {
         }
         ev.emit('connection.update', { receivedPendingNotifications: true });
     });
+    // update credentials when required
     ev.on('creds.update', update => {
         const name = update.me?.name;
+        // if name has just been received
         if (creds.me?.name !== name) {
             logger.debug({ name }, 'updated pushName');
             sendNode({
@@ -888,9 +990,9 @@ const makeSocket = config => {
         logger.debug({ offset: serverTimeOffsetMs }, 'calculated server time offset');
     };
     const getUnifiedSessionId = () => {
-        const offsetMs = 3 * Defaults_1.TimeMs.Day;
+        const offsetMs = 3 * TimeMs.Day;
         const now = Date.now() + serverTimeOffsetMs;
-        const id = (now + offsetMs) % Defaults_1.TimeMs.Week;
+        const id = (now + offsetMs) % TimeMs.Week;
         return id.toString();
     };
     const sendUnifiedSession = async () => {
@@ -916,23 +1018,31 @@ const makeSocket = config => {
             logger.debug({ error }, 'failed to send unified_session telemetry');
         }
     };
+    const registerSocketEndHandler = (handler) => {
+        socketEndHandlers.push(handler);
+    };
+    /**
+     * Fetches your account's standing when it comes to restrictions.
+     * @returns Returns the state of the restrictions.
+     */
     const fetchAccountReachoutTimelock = async () => {
-        const queryResult = await (0, mex_1.executeWMexQuery)({}, Types_1.QueryIds.REACHOUT_TIMELOCK, Types_1.XWAPaths.xwa2_fetch_account_reachout_timelock, query, generateMessageTag);
+        const queryResult = await executeWMexQuery({}, QueryIds.REACHOUT_TIMELOCK, XWAPaths.xwa2_fetch_account_reachout_timelock, query, generateMessageTag);
         const result = {
             isActive: !!queryResult?.is_active,
             timeEnforcementEnds: queryResult?.time_enforcement_ends && queryResult?.time_enforcement_ends !== '0'
                 ? new Date(parseInt(queryResult.time_enforcement_ends, 10) * 1000)
                 : undefined,
-            enforcementType: queryResult?.enforcement_type ?? Types_1.ReachoutTimelockEnforcementType.DEFAULT
+            enforcementType: queryResult?.enforcement_type ?? ReachoutTimelockEnforcementType.DEFAULT
         };
         ev.emit('connection.update', { reachoutTimeLock: result });
         return result;
     };
+    /**
+     * Fetches your account's new chat limits.
+     * @returns Returns the quota and the usage.
+     */
     const fetchNewChatMessageCap = async () => {
-        return (0, mex_1.executeWMexQuery)({ input: { type: 'INDIVIDUAL_NEW_CHAT_MSG' } }, Types_1.QueryIds.MESSAGE_CAPPING_INFO, Types_1.XWAPaths.xwa2_message_capping_info, query, generateMessageTag);
-    };
-    const registerSocketEndHandler = handler => {
-        socketEndHandlers.push(handler);
+        return executeWMexQuery({ input: { type: 'INDIVIDUAL_NEW_CHAT_MSG' } }, QueryIds.MESSAGE_CAPPING_INFO, XWAPaths.xwa2_message_capping_info, query, generateMessageTag);
     };
     return {
         type: 'md',
@@ -952,9 +1062,6 @@ const makeSocket = config => {
         logout,
         end,
         registerSocketEndHandler,
-        toPn,
-        toLID,
-        fetchUsername,
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,
@@ -964,20 +1071,25 @@ const makeSocket = config => {
         updateServerTimeOffset,
         sendUnifiedSession,
         wamBuffer: publicWAMBuffer,
-        waitForConnectionUpdate: (0, Utils_1.bindWaitForConnectionUpdate)(ev),
+        /** Waits for the connection to WA to reach a state */
+        waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
         executeUSyncQuery,
         onWhatsApp,
         fetchAccountReachoutTimelock,
-        fetchNewChatMessageCap
+        fetchNewChatMessageCap,
+        toPn,
+        toLID,
+        fetchUsername
     };
 };
-exports.makeSocket = makeSocket;
+/**
+ * map the websocket error to the right type
+ * so it can be retried by the caller
+ * */
 function mapWebSocketError(handler) {
-    return error => {
-        handler(new boom_1.Boom(`WebSocket Error (${error?.message})`, {
-            statusCode: (0, Utils_1.getCodeFromWSError)(error),
-            data: error
-        }));
+    return (error) => {
+        handler(new Boom(`WebSocket Error (${error?.message})`, { statusCode: getCodeFromWSError(error), data: error }));
     };
 }
+//# sourceMappingURL=socket.js.map