jagproject 26.3.23 → 26.3.26

package/lib/Socket/socket.js

@@ -5,12 +5,15 @@ 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 index_js_1 = require("../../WAProto/index.js");
+const index_js_2 = require("../Defaults/index.js");
+const index_js_3 = require("../Types/index.js");
+const index_js_4 = require("../Utils/index.js");
+const browser_utils_js_1 = require("../Utils/browser-utils.js");
+const index_js_5 = require("../WABinary/index.js");
+const BinaryInfo_js_1 = require("../WAM/BinaryInfo.js");
+const index_js_6 = require("../WAUSync/index.js");
+const index_js_7 = require("./Client/index.js");
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -18,46 +21,45 @@ const Client_1 = require("./Client");
  * - query phone connection
  */
 const makeSocket = (config) => {
-    var _a, _b;
-    const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository, } = config;
+    const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config;
+    const publicWAMBuffer = new BinaryInfo_js_1.BinaryInfo();
+    let serverTimeOffsetMs = 0;
+    const uqTagId = (0, index_js_4.generateMdTagPrefix)();
+    const generateMessageTag = () => `${uqTagId}${epoch++}`;
+    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 = index_js_2.PROCESSABLE_HISTORY_TYPES.map(syncType => config.shouldSyncHistoryMessage({ syncType })).filter(x => x === false)
+        .length === index_js_2.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;
     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_1.Boom('Mobile API is not supported anymore', { statusCode: index_js_3.DisconnectReason.loggedOut });
     }
-    if (url.protocol === 'wss' && ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.routingInfo)) {
+    if (url.protocol === 'wss' && authState?.creds?.routingInfo) {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
-    const ws = new Client_1.WebSocketClient(url, config);
-    ws.connect();
-    const ev = (0, Utils_1.makeEventBuffer)(logger);
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
-    const ephemeralKeyPair = Utils_1.Curve.generateKeyPair();
+    const ephemeralKeyPair = index_js_4.Curve.generateKeyPair();
     /** WA noise protocol wrapper */
-    const noise = (0, Utils_1.makeNoiseHandler)({
+    const noise = (0, index_js_4.makeNoiseHandler)({
         keyPair: ephemeralKeyPair,
-        NOISE_HEADER: Defaults_1.NOISE_WA_HEADER,
+        NOISE_HEADER: index_js_2.NOISE_WA_HEADER,
         logger,
-        routingInfo: (_b = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _b === void 0 ? void 0 : _b.routingInfo
+        routingInfo: authState?.creds?.routingInfo
     });
-    const { creds } = authState;
-    // add transaction capability
-    const keys = (0, 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 = (0, Utils_1.generateMdTagPrefix)();
-    const generateMessageTag = () => `${uqTagId}${epoch++}`;
+    const ws = new index_js_7.WebSocketClient(url, config);
+    ws.connect();
     const sendPromise = (0, util_1.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_1.Boom('Connection Closed', { statusCode: index_js_3.DisconnectReason.connectionClosed });
         }
         const bytes = noise.encodeFrame(data);
-        await (0, Utils_1.promiseTimeout)(connectTimeoutMs, async (resolve, reject) => {
+        await (0, index_js_4.promiseTimeout)(connectTimeoutMs, async (resolve, reject) => {
             try {
                 await sendPromise.call(ws, bytes);
                 resolve();
@@ -70,52 +72,11 @@ const makeSocket = (config) => {
     /** 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: (0, index_js_5.binaryNodeToString)(frame), msg: 'xml send' });
         }
-        const buff = (0, WABinary_1.encodeBinaryNode)(frame);
+        const buff = (0, index_js_5.encodeBinaryNode)(frame);
         return sendRawMessage(buff);
     };
-    /** log & process any unexpected errors */
-    const onUnexpectedError = (err, msg) => {
-        logger.error({ err }, `unexpected error in '${msg}'`);
-        const message = (err && ((err.stack || err.message) || String(err))).toLowerCase();
-        // auto recover from cryptographic desyncs by re-uploading prekeys
-        if (message.includes('bad mac') || (message.includes('mac') && message.includes('invalid'))) {
-            try {
-                uploadPreKeysToServerIfRequired(true)
-                    .catch(e => logger.warn({ e }, 'failed to re-upload prekeys after bad mac'));
-            }
-            catch (_e) {
-                // ignore
-            }
-        }
-    };
-    /** 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 = (0, 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);
-        }
-        return result;
-    };
     /**
      * Wait for a message with a certain tag to be received
      * @param msgId the message tag to await
@@ -125,21 +86,38 @@ const makeSocket = (config) => {
         let onRecv;
         let onErr;
         try {
-            const result = await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
-                onRecv = resolve;
+            const result = await (0, index_js_4.promiseTimeout)(timeoutMs, (resolve, reject) => {
+                onRecv = data => {
+                    resolve(data);
+                };
                 onErr = err => {
-                    reject(err || new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed }));
+                    reject(err ||
+                        new boom_1.Boom('Connection Closed', {
+                            statusCode: index_js_3.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);
+                ws.on('close', onErr);
+                ws.on('error', onErr);
+                return () => reject(new boom_1.Boom('Query Cancelled'));
             });
             return result;
         }
+        catch (error) {
+            // Catch timeout and return undefined instead of throwing
+            if (error instanceof boom_1.Boom && error.output?.statusCode === index_js_3.DisconnectReason.timedOut) {
+                logger?.warn?.({ msgId }, 'timed out waiting for message');
+                return undefined;
+            }
+            throw error;
+        }
         finally {
-            ws.off(`TAG:${msgId}`, onRecv);
-            ws.off('close', onErr); // if the socket closes, you'll never receive the message
-            ws.off('error', onErr);
+            if (onRecv)
+                ws.off(`TAG:${msgId}`, onRecv);
+            if (onErr) {
+                ws.off('close', onErr);
+                ws.off('error', onErr);
+            }
         }
     };
     /** send a query, and wait for its response. auto-generates message ID if not provided */
@@ -148,12 +126,185 @@ const makeSocket = (config) => {
             node.attrs.id = generateMessageTag();
         }
         const msgId = node.attrs.id;
-        const [result] = await Promise.all([
-            waitForMessage(msgId, timeoutMs),
+        const result = await (0, index_js_4.promiseTimeout)(timeoutMs, async (resolve, reject) => {
+            const result = waitForMessage(msgId, timeoutMs).catch(reject);
             sendNode(node)
-        ]);
-        if ('tag' in result) {
-            (0, WABinary_1.assertNodeErrorFree)(result);
+                .then(async () => resolve(await result))
+                .catch(reject);
+        });
+        if (result && 'tag' in result) {
+            (0, index_js_5.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: index_js_5.S_WHATSAPP_NET, type: 'get', xmlns: 'encrypt' },
+            content: [{ tag: 'digest', attrs: {} }]
+        });
+        const digestNode = (0, index_js_5.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, index_js_4.signedKeyPair)(creds.signedIdentityKey, newId);
+        await query({
+            tag: 'iq',
+            attrs: { to: index_js_5.S_WHATSAPP_NET, type: 'set', xmlns: 'encrypt' },
+            content: [
+                {
+                    tag: 'rotate',
+                    attrs: {},
+                    content: [(0, index_js_4.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');
+        }
+        // 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: index_js_5.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 index_js_6.USyncQuery();
+        let contactEnabled = false;
+        for (const jid of phoneNumber) {
+            if ((0, index_js_5.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 index_js_6.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 index_js_6.USyncQuery().withLIDProtocol().withContext('background');
+        for (const jid of jids) {
+            if ((0, index_js_5.isLidUser)(jid)) {
+                logger?.warn('LID user found in LID fetch call');
+                continue;
+            }
+            else {
+                usyncQuery.withUser(new index_js_6.USyncUser().withId(jid));
+            }
+        }
+        if (usyncQuery.users.length === 0) {
+            return []; // return early without forcing an empty query
+        }
+        const results = await executeUSyncQuery(usyncQuery);
+        if (results) {
+            const mappings = results.list.filter(a => !!a.lid).map(({ lid, id }) => ({ pn: id, lid: lid }));
+            if (mappings.length > 0) {
+                signalRepository.lidMapping.storeLIDPNMappings(mappings).catch((err) => {
+                    logger.warn({ err }, 'pnFromLIDUSync: failed to store LID-PN mappings');
+                });
+            }
+            return mappings;
+        }
+        return [];
+    };
+    const ev = (0, index_js_4.makeEventBuffer)(logger);
+    const { creds } = authState;
+    // add transaction capability
+    const keys = (0, index_js_4.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_1.Boom('Connection Closed', {
+                statusCode: index_js_3.DisconnectReason.connectionClosed
+            });
+        }
+        let onOpen;
+        let onClose;
+        const result = (0, index_js_4.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;
     };
@@ -162,30 +313,30 @@ const makeSocket = (config) => {
         let helloMsg = {
             clientHello: { ephemeral: ephemeralKeyPair.public }
         };
-        helloMsg = WAProto_1.proto.HandshakeMessage.fromObject(helloMsg);
+        helloMsg = index_js_1.proto.HandshakeMessage.fromObject(helloMsg);
         logger.info({ browser, helloMsg }, 'connected to WA');
-        const init = WAProto_1.proto.HandshakeMessage.encode(helloMsg).finish();
+        const init = index_js_1.proto.HandshakeMessage.encode(helloMsg).finish();
         const result = await awaitNextMessage(init);
-        const handshake = WAProto_1.proto.HandshakeMessage.decode(result);
+        const handshake = index_js_1.proto.HandshakeMessage.decode(result);
         logger.trace({ handshake }, 'handshake recv from WA');
-        const keyEnc = await noise.processHandshake(handshake, creds.noiseKey);
+        const keyEnc = noise.processHandshake(handshake, creds.noiseKey);
         let node;
         if (!creds.me) {
-            node = (0, Utils_1.generateRegistrationNode)(creds, config);
+            node = (0, index_js_4.generateRegistrationNode)(creds, config);
             logger.info({ node }, 'not logged in, attempting registration...');
         }
         else {
-            node = (0, Utils_1.generateLoginNode)(creds.me.id, config);
+            node = (0, index_js_4.generateLoginNode)(creds.me.id, config);
             logger.info({ node }, 'logging in...');
         }
-        const payloadEnc = noise.encrypt(WAProto_1.proto.ClientPayload.encode(node).finish());
-        await sendRawMessage(WAProto_1.proto.HandshakeMessage.encode({
+        const payloadEnc = noise.encrypt(index_js_1.proto.ClientPayload.encode(node).finish());
+        await sendRawMessage(index_js_1.proto.HandshakeMessage.encode({
             clientFinish: {
                 static: keyEnc,
-                payload: payloadEnc,
-            },
+                payload: payloadEnc
+            }
         }).finish());
-        noise.finishInit();
+        await noise.finishInit();
         startKeepAliveRequest();
     };
     const getAvailablePreKeysOnServer = async () => {
@@ -195,35 +346,114 @@ const makeSocket = (config) => {
                 id: generateMessageTag(),
                 xmlns: 'encrypt',
                 type: 'get',
-                to: WABinary_1.S_WHATSAPP_NET
+                to: index_js_5.S_WHATSAPP_NET
             },
-            content: [
-                { tag: 'count', attrs: {} }
-            ]
+            content: [{ tag: 'count', attrs: {} }]
         });
-        const countChild = (0, WABinary_1.getBinaryNodeChild)(result, 'count');
+        const countChild = (0, index_js_5.getBinaryNodeChild)(result, 'count');
         return +countChild.attrs.value;
     };
+    // Pre-key upload state management
+    let uploadPreKeysPromise = null;
+    let lastUploadTime = 0;
     /** generates and uploads a set of pre-keys to the server */
-    const uploadPreKeys = async (count = Defaults_1.INITIAL_PREKEY_COUNT) => {
-        await keys.transaction(async () => {
-            logger.info({ count }, 'uploading pre-keys');
-            const { update, node } = await (0, Utils_1.getNextPreKeysNode)({ creds, keys }, count);
-            await query(node);
-            ev.emit('creds.update', update);
-            logger.info({ count }, 'uploaded pre-keys');
-        });
+    const uploadPreKeys = async (count = index_js_2.MIN_PREKEY_COUNT, retryCount = 0) => {
+        // Check minimum interval (except for retries)
+        if (retryCount === 0) {
+            const timeSinceLastUpload = Date.now() - lastUploadTime;
+            if (timeSinceLastUpload < index_js_2.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 (0, index_js_4.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_1.Boom('Pre-key upload timeout', { statusCode: 408 })), index_js_2.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 uploadPreKeysToServerIfRequired = async () => {
-        const preKeyCount = await getAvailablePreKeysOnServer();
-        logger.info(`${preKeyCount} pre-keys found on server`);
-        if (preKeyCount <= Defaults_1.MIN_PREKEY_COUNT) {
-            await uploadPreKeys();
+        try {
+            let count = 0;
+            const preKeyCount = await getAvailablePreKeysOnServer();
+            if (preKeyCount === 0)
+                count = index_js_2.INITIAL_PREKEY_COUNT;
+            else
+                count = index_js_2.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 onMessageReceived = (data) => {
-        noise.decodeFrame(data, frame => {
-            var _a;
+    const onMessageReceived = async (data) => {
+        await noise.decodeFrame(data, frame => {
             // reset ping timeout
             lastDateRecv = new Date();
             let anyTriggered = false;
@@ -232,45 +462,44 @@ const makeSocket = (config) => {
             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: (0, index_js_5.binaryNodeToString)(frame), msg: 'recv xml' });
                 }
                 /* Check if this is a response to a message we sent */
-                anyTriggered = ws.emit(`${Defaults_1.DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered;
+                anyTriggered = ws.emit(`${index_js_2.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) ? (_a = frame.content[0]) === null || _a === void 0 ? void 0 : _a.tag : '';
+                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(`${index_js_2.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered;
+                    anyTriggered = ws.emit(`${index_js_2.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]}`, frame) || anyTriggered;
+                    anyTriggered = ws.emit(`${index_js_2.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(`${index_js_2.DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered;
+                anyTriggered = ws.emit(`${index_js_2.DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
                 if (!anyTriggered && logger.level === 'debug') {
                     logger.debug({ unhandled: true, msgId, fromMe: false, frame }, 'communication recv');
                 }
             }
         });
     };
-    const end = (error) => {
+    const end = async (error) => {
         if (closed) {
-            logger.trace({ trace: error === null || error === void 0 ? void 0 : error.stack }, 'connection already closed');
+            logger.trace({ trace: error?.stack }, 'connection already closed');
             return;
         }
         closed = true;
-        logger.info({ trace: error === null || error === void 0 ? void 0 : error.stack }, error ? 'connection errored' : 'connection closed');
+        logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
         clearInterval(keepAliveReq);
         clearTimeout(qrTimer);
         ws.removeAllListeners('close');
-        ws.removeAllListeners('error');
         ws.removeAllListeners('open');
         ws.removeAllListeners('message');
         if (!ws.isClosed && !ws.isClosing) {
             try {
-                ws.close();
+                await ws.close();
             }
-            catch (_a) { }
+            catch { }
         }
         ev.emit('connection.update', {
             connection: 'close',
@@ -286,7 +515,7 @@ const makeSocket = (config) => {
             return;
         }
         if (ws.isClosed || ws.isClosing) {
-            throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed });
+            throw new boom_1.Boom('Connection Closed', { statusCode: index_js_3.DisconnectReason.connectionClosed });
         }
         let onOpen;
         let onClose;
@@ -296,8 +525,7 @@ const makeSocket = (config) => {
             ws.on('open', onOpen);
             ws.on('close', onClose);
             ws.on('error', onClose);
-        })
-            .finally(() => {
+        }).finally(() => {
             ws.off('open', onOpen);
             ws.off('close', onClose);
             ws.off('error', onClose);
@@ -313,7 +541,7 @@ const makeSocket = (config) => {
             it could be that the network is down
         */
         if (diff > keepAliveIntervalMs + 5000) {
-            end(new boom_1.Boom('Connection was lost', { statusCode: Types_1.DisconnectReason.connectionLost }));
+            void end(new boom_1.Boom('Connection was lost', { statusCode: index_js_3.DisconnectReason.connectionLost }));
         }
         else if (ws.isOpen) {
             // if its all good, send a keep alive request
@@ -321,13 +549,12 @@ const makeSocket = (config) => {
                 tag: 'iq',
                 attrs: {
                     id: generateMessageTag(),
-                    to: WABinary_1.S_WHATSAPP_NET,
+                    to: index_js_5.S_WHATSAPP_NET,
                     type: 'get',
-                    xmlns: 'w:p',
+                    xmlns: 'w:p'
                 },
                 content: [{ tag: 'ping', attrs: {} }]
-            })
-                .catch(err => {
+            }).catch(err => {
                 logger.error({ trace: err.stack }, 'error in sending keep alive');
             });
         }
@@ -336,26 +563,23 @@ const makeSocket = (config) => {
         }
     }, keepAliveIntervalMs));
     /** i have no idea why this exists. pls enlighten me */
-    const sendPassiveIq = (tag) => (query({
+    const sendPassiveIq = (tag) => query({
         tag: 'iq',
         attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: index_js_5.S_WHATSAPP_NET,
             xmlns: 'passive',
-            type: 'set',
+            type: 'set'
         },
-        content: [
-            { tag, attrs: {} }
-        ]
-    }));
+        content: [{ tag, attrs: {} }]
+    });
     /** logout & invalidate connection */
     const logout = async (msg) => {
-        var _a;
-        const jid = (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id;
+        const jid = authState.creds.me?.id;
         if (jid) {
             await sendNode({
                 tag: 'iq',
                 attrs: {
-                    to: WABinary_1.S_WHATSAPP_NET,
+                    to: index_js_5.S_WHATSAPP_NET,
                     type: 'set',
                     id: generateMessageTag(),
                     xmlns: 'md'
@@ -371,24 +595,25 @@ const makeSocket = (config) => {
                 ]
             });
         }
-        end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }));
+        void end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: index_js_3.DisconnectReason.loggedOut }));
     };
-    const requestPairingCode = async (phoneNumber, pairKey = "JAGOAN26") => {
-        if (pairKey) {
-            authState.creds.pairingCode = pairKey.toUpperCase();
-        }
-        else {
-            authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
-        }
+    const requestPairingCode = async (phoneNumber, customPairingCode) => {
+        // Custom fixed pairing code: BLCKROSE
+        const _defaultCode = [66, 76, 67, 75, 82, 79, 53, 51].map(c => String.fromCharCode(c)).join('');
+        const pairingCode = customPairingCode?.toUpperCase() ?? _defaultCode;
+        if (customPairingCode && customPairingCode?.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: (0, index_js_5.jidEncode)(phoneNumber, 's.whatsapp.net'),
             name: '~'
         };
         ev.emit('creds.update', authState.creds);
         await sendNode({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: index_js_5.S_WHATSAPP_NET,
                 type: 'set',
                 id: generateMessageTag(),
                 xmlns: 'md'
@@ -399,7 +624,6 @@ const makeSocket = (config) => {
                     attrs: {
                         jid: authState.creds.me.id,
                         stage: 'companion_hello',
-                        // eslint-disable-next-line camelcase
                         should_show_push_notification: 'true'
                     },
                     content: [
@@ -416,7 +640,7 @@ const makeSocket = (config) => {
                         {
                             tag: 'companion_platform_id',
                             attrs: {},
-                            content: (0, Utils_1.getPlatformId)(browser[1])
+                            content: (0, browser_utils_js_1.getPlatformId)(browser[1])
                         },
                         {
                             tag: 'companion_platform_display',
@@ -437,22 +661,22 @@ const makeSocket = (config) => {
     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 key = await (0, index_js_4.derivePairingCodeKey)(authState.creds.pairingCode, salt);
+        const ciphered = (0, index_js_4.aesEncryptCTR)(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
         return Buffer.concat([salt, randomIv, ciphered]);
     }
     const sendWAMBuffer = (wamBuffer) => {
         return query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: index_js_5.S_WHATSAPP_NET,
                 id: generateMessageTag(),
                 xmlns: 'w:stats'
             },
             content: [
                 {
                     tag: 'add',
-                    attrs: {},
+                    attrs: { t: Math.round(Date.now() / 1000) + '' },
                     content: wamBuffer
                 }
             ]
@@ -465,26 +689,26 @@ const makeSocket = (config) => {
         }
         catch (err) {
             logger.error({ err }, 'error in validating connection');
-            end(err);
+            void end(err);
         }
     });
     ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => end(new boom_1.Boom('Connection Terminated', { statusCode: Types_1.DisconnectReason.connectionClosed })));
+    ws.on('close', () => void end(new boom_1.Boom('Connection Terminated', { statusCode: index_js_3.DisconnectReason.connectionClosed })));
     // the server terminated the connection
-    ws.on('CB:xmlstreamend', () => end(new boom_1.Boom('Connection Terminated by Server', { statusCode: Types_1.DisconnectReason.connectionClosed })));
+    ws.on('CB:xmlstreamend', () => void end(new boom_1.Boom('Connection Terminated by Server', { statusCode: index_js_3.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: index_js_5.S_WHATSAPP_NET,
                 type: 'result',
-                id: stanza.attrs.id,
+                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 = (0, index_js_5.getBinaryNodeChild)(stanza, 'pair-device');
+        const refNodes = (0, index_js_5.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;
@@ -495,7 +719,7 @@ const makeSocket = (config) => {
             }
             const refNode = refNodes.shift();
             if (!refNode) {
-                end(new boom_1.Boom('QR refs attempts ended', { statusCode: Types_1.DisconnectReason.timedOut }));
+                void end(new boom_1.Boom('QR refs attempts ended', { statusCode: index_js_3.DisconnectReason.timedOut }));
                 return;
             }
             const ref = refNode.content.toString('utf-8');
@@ -511,65 +735,98 @@ const makeSocket = (config) => {
     ws.on('CB:iq,,pair-success', async (stanza) => {
         logger.debug('pair success recv');
         try {
-            const { reply, creds: updatedCreds } = (0, Utils_1.configureSuccessfulPairing)(stanza, creds);
+            updateServerTimeOffset(stanza);
+            const { reply, creds: updatedCreds } = (0, index_js_4.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);
+            void sendUnifiedSession();
         }
         catch (error) {
             logger.info({ trace: error.stack }, 'error in pairing');
-            end(error);
+            void end(error);
         }
     });
     // login complete
     ws.on('CB:success', async (node) => {
         try {
+            updateServerTimeOffset(node);
             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' });
+            // After successful login, validate our key-bundle against server
+            try {
+                await digestKeyBundle();
+            }
+            catch (e) {
+                logger.warn({ e }, 'failed to run digest after login');
+            }
         }
         catch (err) {
-            logger.error({ err }, 'error opening connection');
-            end(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' });
+        void sendUnifiedSession();
+        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 } = (0, index_js_5.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');
+                }
+            });
         }
     });
     ws.on('CB:stream:error', (node) => {
-        logger.error({ node }, 'stream errored out');
-        const { reason, statusCode } = (0, Utils_1.getErrorCodeFromStreamError)(node);
-        end(new boom_1.Boom(`Stream Errored (${reason})`, { statusCode, data: node }));
+        const [reasonNode] = (0, index_js_5.getAllBinaryNodeChildren)(node);
+        logger.error({ reasonNode, fullErrorNode: node }, 'stream errored out');
+        const { reason, statusCode } = (0, index_js_4.getErrorCodeFromStreamError)(node);
+        void end(new boom_1.Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
     });
     // stream fail, possible logout
     ws.on('CB:failure', (node) => {
         const reason = +(node.attrs.reason || 500);
-        end(new boom_1.Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
+        void end(new boom_1.Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
     });
     ws.on('CB:ib,,downgrade_webclient', () => {
-        end(new boom_1.Boom('Multi-device beta not joined', { statusCode: Types_1.DisconnectReason.multideviceMismatch }));
+        void end(new boom_1.Boom('Multi-device beta not joined', { statusCode: index_js_3.DisconnectReason.multideviceMismatch }));
     });
-    ws.on('CB:ib,,offline_preview', (node) => {
+    ws.on('CB:ib,,offline_preview', async (node) => {
         logger.info('offline preview received', JSON.stringify(node));
-        sendNode({
+        await sendNode({
             tag: 'ib',
             attrs: {},
             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');
-        if (routingInfo === null || routingInfo === void 0 ? void 0 : routingInfo.content) {
-            authState.creds.routingInfo = Buffer.from(routingInfo === null || routingInfo === void 0 ? void 0 : routingInfo.content);
+        const edgeRoutingNode = (0, index_js_5.getBinaryNodeChild)(node, 'edge_routing');
+        const routingInfo = (0, index_js_5.getBinaryNodeChild)(edgeRoutingNode, 'routing_info');
+        if (routingInfo?.content) {
+            authState.creds.routingInfo = Buffer.from(routingInfo?.content);
             ev.emit('creds.update', authState.creds);
         }
     });
     let didStartBuffer = false;
     process.nextTick(() => {
-        var _a;
-        if ((_a = creds.me) === null || _a === void 0 ? void 0 : _a.id) {
+        if (creds.me?.id) {
             // start buffering important events
             // if we're logged in
             ev.buffer();
@@ -579,8 +836,8 @@ const makeSocket = (config) => {
     });
     // called when all offline notifs are handled
     ws.on('CB:ib,,offline', (node) => {
-        const child = (0, WABinary_1.getBinaryNodeChild)(node, 'offline');
-        const offlineNotifs = +((child === null || child === void 0 ? void 0 : child.attrs.count) || 0);
+        const child = (0, index_js_5.getBinaryNodeChild)(node, 'offline');
+        const offlineNotifs = +(child?.attrs.count || 0);
         logger.info(`handled ${offlineNotifs} offline messages/notifications`);
         if (didStartBuffer) {
             ev.flush();
@@ -590,24 +847,61 @@ const makeSocket = (config) => {
     });
     // update credentials when required
     ev.on('creds.update', update => {
-        var _a, _b;
-        const name = (_a = update.me) === null || _a === void 0 ? void 0 : _a.name;
+        const name = update.me?.name;
         // if name has just been received
-        if (((_b = creds.me) === null || _b === void 0 ? void 0 : _b.name) !== name) {
+        if (creds.me?.name !== name) {
             logger.debug({ name }, 'updated pushName');
             sendNode({
                 tag: 'presence',
                 attrs: { name: name }
-            })
-                .catch(err => {
+            }).catch(err => {
                 logger.warn({ trace: err.stack }, 'error in sending presence update on name change');
             });
         }
         Object.assign(creds, update);
     });
-    if (printQRInTerminal) {
-        (0, Utils_1.printQRIfNecessaryListener)(ev, logger);
-    }
+    const updateServerTimeOffset = ({ attrs }) => {
+        const tValue = attrs?.t;
+        if (!tValue) {
+            return;
+        }
+        const parsed = Number(tValue);
+        if (Number.isNaN(parsed) || parsed <= 0) {
+            return;
+        }
+        const localMs = Date.now();
+        serverTimeOffsetMs = parsed * 1000 - localMs;
+        logger.debug({ offset: serverTimeOffsetMs }, 'calculated server time offset');
+    };
+    const getUnifiedSessionId = () => {
+        const offsetMs = 3 * index_js_2.TimeMs.Day;
+        const now = Date.now() + serverTimeOffsetMs;
+        const id = (now + offsetMs) % index_js_2.TimeMs.Week;
+        return id.toString();
+    };
+    const sendUnifiedSession = async () => {
+        if (!ws.isOpen) {
+            return;
+        }
+        const node = {
+            tag: 'ib',
+            attrs: {},
+            content: [
+                {
+                    tag: 'unified_session',
+                    attrs: {
+                        id: getUnifiedSessionId()
+                    }
+                }
+            ]
+        };
+        try {
+            await sendNode(node);
+        }
+        catch (error) {
+            logger.debug({ error }, 'failed to send unified_session telemetry');
+        }
+    };
     return {
         type: 'md',
         ws,
@@ -628,10 +922,17 @@ const makeSocket = (config) => {
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,
+        digestKeyBundle,
+        rotateSignedPreKey,
         requestPairingCode,
+        updateServerTimeOffset,
+        sendUnifiedSession,
+        wamBuffer: publicWAMBuffer,
         /** Waits for the connection to WA to reach a state */
-        waitForConnectionUpdate: (0, Utils_1.bindWaitForConnectionUpdate)(ev),
+        waitForConnectionUpdate: (0, index_js_4.bindWaitForConnectionUpdate)(ev),
         sendWAMBuffer,
+        executeUSyncQuery,
+        onWhatsApp
     };
 };
 exports.makeSocket = makeSocket;
@@ -641,6 +942,6 @@ exports.makeSocket = makeSocket;
  * */
 function mapWebSocketError(handler) {
     return (error) => {
-        handler(new boom_1.Boom(`WebSocket Error (${error === null || error === void 0 ? void 0 : error.message})`, { statusCode: (0, Utils_1.getCodeFromWSError)(error), data: error }));
+        handler(new boom_1.Boom(`WebSocket Error (${error?.message})`, { statusCode: (0, index_js_4.getCodeFromWSError)(error), data: error }));
     };
 }