@baileys-md/baileys 11.0.3 → 11.1.0

package/lib/Socket/socket.js

@@ -1,62 +1,65 @@
-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 } from '../Defaults/index.js';
-import { DisconnectReason } from '../Types/index.js';
-import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, getPlatformId, makeEventBuffer, makeNoiseHandler, promiseTimeout } from '../Utils/index.js';
-import { assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getBinaryNodeChild, getBinaryNodeChildren, jidEncode, S_WHATSAPP_NET } from '../WABinary/index.js';
-import { WebSocketClient } from './Client/index.js';
+"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 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");
 /**
  * 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;
-    if (printQRInTerminal) {
-        console.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 url = typeof waWebSocketUrl === 'string' ? new URL(waWebSocketUrl) : waWebSocketUrl;
-    if (config.mobile || url.protocol === 'tcp:') {
-        throw new Boom('Mobile API is not supported anymore', { statusCode: DisconnectReason.loggedOut });
+const makeSocket = (config) => {
+    var _a, _b;
+    const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository, } = config;
+    let url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
+    config.mobile = config.mobile || url.protocol === 'tcp:';
+    if (config.mobile && url.protocol !== 'tcp:') {
+        url = new url_1.URL(`tcp://${Defaults_1.MOBILE_ENDPOINT}:${Defaults_1.MOBILE_PORT}`);
     }
-    if (url.protocol === 'wss' && authState?.creds?.routingInfo) {
+    if (!config.mobile && url.protocol === 'wss' && ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.routingInfo)) {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
-    const ws = new WebSocketClient(url, config);
+    const ws = config.socket ? config.socket : config.mobile ? new Client_1.MobileSocketClient(url, config) : new Client_1.WebSocketClient(url, config);
     ws.connect();
-    const ev = makeEventBuffer(logger);
+    const ev = (0, Utils_1.makeEventBuffer)(logger);
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
-    const ephemeralKeyPair = Curve.generateKeyPair();
+    const ephemeralKeyPair = Utils_1.Curve.generateKeyPair();
     /** WA noise protocol wrapper */
-    const noise = makeNoiseHandler({
+    const noise = (0, Utils_1.makeNoiseHandler)({
         keyPair: ephemeralKeyPair,
-        NOISE_HEADER: NOISE_WA_HEADER,
+        NOISE_HEADER: config.mobile ? Defaults_1.MOBILE_NOISE_HEADER : Defaults_1.NOISE_WA_HEADER,
+        mobile: config.mobile,
         logger,
-        routingInfo: authState?.creds?.routingInfo
+        routingInfo: (_b = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _b === void 0 ? void 0 : _b.routingInfo
     });
     const { creds } = authState;
     // add transaction capability
-    const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
+    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 = generateMdTagPrefix();
+    const uqTagId = (0, Utils_1.generateMdTagPrefix)();
     const generateMessageTag = () => `${uqTagId}${epoch++}`;
-    const sendPromise = promisify(ws.send);
+    const sendPromise = (0, util_1.promisify)(ws.send);
     /** send a raw buffer */
     const sendRawMessage = async (data) => {
         if (!ws.isOpen) {
-            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
+            throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed });
         }
         const bytes = noise.encodeFrame(data);
-        await promiseTimeout(connectTimeoutMs, async (resolve, reject) => {
+        await (0, Utils_1.promiseTimeout)(connectTimeoutMs, async (resolve, reject) => {
             try {
                 await sendPromise.call(ws, bytes);
                 resolve();
@@ -69,9 +72,9 @@ export const makeSocket = (config) => {
     /** send a binary node */
     const sendNode = (frame) => {
         if (logger.level === 'trace') {
-            logger.trace({ xml: binaryNodeToString(frame), msg: 'xml send' });
+            logger.trace({ xml: (0, WABinary_1.binaryNodeToString)(frame), msg: 'xml send' });
         }
-        const buff = encodeBinaryNode(frame);
+        const buff = (0, WABinary_1.encodeBinaryNode)(frame);
         return sendRawMessage(buff);
     };
     /** log & process any unexpected errors */
@@ -81,19 +84,20 @@ export const makeSocket = (config) => {
     /** await the next incoming message */
     const awaitNextMessage = async (sendMsg) => {
         if (!ws.isOpen) {
-            throw new Boom('Connection Closed', {
-                statusCode: DisconnectReason.connectionClosed
+            throw new boom_1.Boom('Connection Closed', {
+                statusCode: Types_1.DisconnectReason.connectionClosed
             });
         }
         let onOpen;
         let onClose;
-        const result = promiseTimeout(connectTimeoutMs, (resolve, reject) => {
+        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(() => {
+        })
+            .finally(() => {
             ws.off('frame', onOpen);
             ws.off('close', onClose);
             ws.off('error', onClose);
@@ -112,10 +116,10 @@ export const makeSocket = (config) => {
         let onRecv;
         let onErr;
         try {
-            const result = await promiseTimeout(timeoutMs, (resolve, reject) => {
+            const result = await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
                 onRecv = resolve;
                 onErr = err => {
-                    reject(err || new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
+                    reject(err || new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed }));
                 };
                 ws.on(`TAG:${msgId}`, onRecv);
                 ws.on('close', onErr); // if the socket closes, you'll never receive the message
@@ -135,9 +139,12 @@ export const makeSocket = (config) => {
             node.attrs.id = generateMessageTag();
         }
         const msgId = node.attrs.id;
-        const [result] = await Promise.all([waitForMessage(msgId, timeoutMs), sendNode(node)]);
+        const [result] = await Promise.all([
+            waitForMessage(msgId, timeoutMs),
+            sendNode(node)
+        ]);
         if ('tag' in result) {
-            assertNodeErrorFree(result);
+            (0, WABinary_1.assertNodeErrorFree)(result);
         }
         return result;
     };
@@ -146,28 +153,31 @@ export const makeSocket = (config) => {
         let helloMsg = {
             clientHello: { ephemeral: ephemeralKeyPair.public }
         };
-        helloMsg = proto.HandshakeMessage.fromObject(helloMsg);
+        helloMsg = WAProto_1.proto.HandshakeMessage.fromObject(helloMsg);
         logger.info({ browser, helloMsg }, 'connected to WA');
-        const init = proto.HandshakeMessage.encode(helloMsg).finish();
+        const init = WAProto_1.proto.HandshakeMessage.encode(helloMsg).finish();
         const result = await awaitNextMessage(init);
-        const handshake = proto.HandshakeMessage.decode(result);
+        const handshake = WAProto_1.proto.HandshakeMessage.decode(result);
         logger.trace({ handshake }, 'handshake recv from WA');
         const keyEnc = await noise.processHandshake(handshake, creds.noiseKey);
         let node;
-        if (!creds.me) {
-            node = generateRegistrationNode(creds, config);
+        if (config.mobile) {
+            node = (0, Utils_1.generateMobileNode)(config);
+        }
+        else if (!creds.me) {
+            node = (0, Utils_1.generateRegistrationNode)(creds, config);
             logger.info({ node }, 'not logged in, attempting registration...');
         }
         else {
-            node = generateLoginNode(creds.me.id, config);
+            node = (0, Utils_1.generateLoginNode)(creds.me.id, config);
             logger.info({ node }, 'logging in...');
         }
-        const payloadEnc = noise.encrypt(proto.ClientPayload.encode(node).finish());
-        await sendRawMessage(proto.HandshakeMessage.encode({
+        const payloadEnc = noise.encrypt(WAProto_1.proto.ClientPayload.encode(node).finish());
+        await sendRawMessage(WAProto_1.proto.HandshakeMessage.encode({
             clientFinish: {
                 static: keyEnc,
-                payload: payloadEnc
-            }
+                payload: payloadEnc,
+            },
         }).finish());
         noise.finishInit();
         startKeepAliveRequest();
@@ -179,18 +189,20 @@ export const makeSocket = (config) => {
                 id: generateMessageTag(),
                 xmlns: 'encrypt',
                 type: 'get',
-                to: S_WHATSAPP_NET
+                to: WABinary_1.S_WHATSAPP_NET
             },
-            content: [{ tag: 'count', attrs: {} }]
+            content: [
+                { tag: 'count', attrs: {} }
+            ]
         });
-        const countChild = getBinaryNodeChild(result, 'count');
+        const countChild = (0, WABinary_1.getBinaryNodeChild)(result, 'count');
         return +countChild.attrs.value;
     };
     /** generates and uploads a set of pre-keys to the server */
-    const uploadPreKeys = async (count = INITIAL_PREKEY_COUNT) => {
+    const uploadPreKeys = async (count = Defaults_1.INITIAL_PREKEY_COUNT) => {
         await keys.transaction(async () => {
             logger.info({ count }, 'uploading pre-keys');
-            const { update, node } = await getNextPreKeysNode({ creds, keys }, count);
+            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');
@@ -199,12 +211,13 @@ export const makeSocket = (config) => {
     const uploadPreKeysToServerIfRequired = async () => {
         const preKeyCount = await getAvailablePreKeysOnServer();
         logger.info(`${preKeyCount} pre-keys found on server`);
-        if (preKeyCount <= MIN_PREKEY_COUNT) {
+        if (preKeyCount <= Defaults_1.MIN_PREKEY_COUNT) {
             await uploadPreKeys();
         }
     };
     const onMessageReceived = (data) => {
         noise.decodeFrame(data, frame => {
+            var _a;
             // reset ping timeout
             lastDateRecv = new Date();
             let anyTriggered = false;
@@ -213,21 +226,21 @@ export const makeSocket = (config) => {
             if (!(frame instanceof Uint8Array)) {
                 const msgId = frame.attrs.id;
                 if (logger.level === 'trace') {
-                    logger.trace({ xml: binaryNodeToString(frame), msg: 'recv xml' });
+                    logger.trace({ xml: (0, WABinary_1.binaryNodeToString)(frame), msg: 'recv xml' });
                 }
                 /* Check if this is a response to a message we sent */
-                anyTriggered = ws.emit(`${DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered;
+                anyTriggered = ws.emit(`${Defaults_1.DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered;
                 /* Check if this is a response to a message we are expecting */
                 const l0 = frame.tag;
                 const l1 = frame.attrs || {};
-                const l2 = Array.isArray(frame.content) ? frame.content[0]?.tag : '';
-                for (const key of Object.keys(l1)) {
-                    anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered;
-                    anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]}`, frame) || anyTriggered;
-                    anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}`, frame) || anyTriggered;
-                }
-                anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered;
-                anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
+                const l2 = Array.isArray(frame.content) ? (_a = frame.content[0]) === null || _a === void 0 ? void 0 : _a.tag : '';
+                Object.keys(l1).forEach(key => {
+                    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(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered;
+                anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
                 if (!anyTriggered && logger.level === 'debug') {
                     logger.debug({ unhandled: true, msgId, fromMe: false, frame }, 'communication recv');
                 }
@@ -236,21 +249,22 @@ export const makeSocket = (config) => {
     };
     const end = (error) => {
         if (closed) {
-            logger.trace({ trace: error?.stack }, 'connection already closed');
+            logger.trace({ trace: error === null || error === void 0 ? void 0 : error.stack }, 'connection already closed');
             return;
         }
         closed = true;
-        logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
+        logger.info({ trace: error === null || error === void 0 ? void 0 : 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();
             }
-            catch { }
+            catch (_a) { }
         }
         ev.emit('connection.update', {
             connection: 'close',
@@ -266,7 +280,7 @@ export const makeSocket = (config) => {
             return;
         }
         if (ws.isClosed || ws.isClosing) {
-            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
+            throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed });
         }
         let onOpen;
         let onClose;
@@ -276,7 +290,8 @@ export 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);
@@ -292,7 +307,7 @@ export const makeSocket = (config) => {
             it could be that the network is down
         */
         if (diff > keepAliveIntervalMs + 5000) {
-            end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+            end(new boom_1.Boom('Connection was lost', { statusCode: Types_1.DisconnectReason.connectionLost }));
         }
         else if (ws.isOpen) {
             // if its all good, send a keep alive request
@@ -300,12 +315,13 @@ export const makeSocket = (config) => {
                 tag: 'iq',
                 attrs: {
                     id: generateMessageTag(),
-                    to: S_WHATSAPP_NET,
+                    to: WABinary_1.S_WHATSAPP_NET,
                     type: 'get',
-                    xmlns: 'w:p'
+                    xmlns: 'w:p',
                 },
                 content: [{ tag: 'ping', attrs: {} }]
-            }).catch(err => {
+            })
+                .catch(err => {
                 logger.error({ trace: err.stack }, 'error in sending keep alive');
             });
         }
@@ -314,23 +330,26 @@ export 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: S_WHATSAPP_NET,
+            to: WABinary_1.S_WHATSAPP_NET,
             xmlns: 'passive',
-            type: 'set'
+            type: 'set',
         },
-        content: [{ tag, attrs: {} }]
-    });
+        content: [
+            { tag, attrs: {} }
+        ]
+    }));
     /** logout & invalidate connection */
     const logout = async (msg) => {
-        const jid = authState.creds.me?.id;
+        var _a;
+        const jid = (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id;
         if (jid) {
             await sendNode({
                 tag: 'iq',
                 attrs: {
-                    to: S_WHATSAPP_NET,
+                    to: WABinary_1.S_WHATSAPP_NET,
                     type: 'set',
                     id: generateMessageTag(),
                     xmlns: 'md'
@@ -346,23 +365,24 @@ export const makeSocket = (config) => {
                 ]
             });
         }
-        end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
+        end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }));
     };
-    const requestPairingCode = async (phoneNumber, customPairingCode) => {
-        const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5));
-        if (customPairingCode && customPairingCode?.length !== 8) {
-            throw new Error('Custom pairing code must be exactly 8 chars');
+    const requestPairingCode = async (phoneNumber, pairCode) => {
+        if (pairCode) {
+            authState.creds.pairingCode = pairCode.substring(0, 8).toUpperCase();
+        }
+        else {
+            authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
         }
-        authState.creds.pairingCode = pairingCode;
         authState.creds.me = {
-            id: jidEncode(phoneNumber, 's.whatsapp.net'),
+            id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
             name: '~'
         };
         ev.emit('creds.update', authState.creds);
         await sendNode({
             tag: 'iq',
             attrs: {
-                to: S_WHATSAPP_NET,
+                to: WABinary_1.S_WHATSAPP_NET,
                 type: 'set',
                 id: generateMessageTag(),
                 xmlns: 'md'
@@ -373,6 +393,7 @@ export const makeSocket = (config) => {
                     attrs: {
                         jid: authState.creds.me.id,
                         stage: 'companion_hello',
+                        // eslint-disable-next-line camelcase
                         should_show_push_notification: 'true'
                     },
                     content: [
@@ -389,7 +410,7 @@ export const makeSocket = (config) => {
                         {
                             tag: 'companion_platform_id',
                             attrs: {},
-                            content: getPlatformId(browser[1])
+                            content: (0, Utils_1.getPlatformId)(browser[1])
                         },
                         {
                             tag: 'companion_platform_display',
@@ -408,17 +429,17 @@ export const makeSocket = (config) => {
         return authState.creds.pairingCode;
     };
     async function generatePairingKey() {
-        const salt = randomBytes(32);
-        const randomIv = randomBytes(16);
-        const key = await derivePairingCodeKey(authState.creds.pairingCode, salt);
-        const ciphered = aesEncryptCTR(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
+        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);
         return Buffer.concat([salt, randomIv, ciphered]);
     }
     const sendWAMBuffer = (wamBuffer) => {
         return query({
             tag: 'iq',
             attrs: {
-                to: S_WHATSAPP_NET,
+                to: WABinary_1.S_WHATSAPP_NET,
                 id: generateMessageTag(),
                 xmlns: 'w:stats'
             },
@@ -442,22 +463,22 @@ export const makeSocket = (config) => {
         }
     });
     ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('close', () => end(new boom_1.Boom('Connection Terminated', { statusCode: Types_1.DisconnectReason.connectionClosed })));
     // the server terminated the connection
-    ws.on('CB:xmlstreamend', () => end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('CB:xmlstreamend', () => end(new boom_1.Boom('Connection Terminated by Server', { statusCode: Types_1.DisconnectReason.connectionClosed })));
     // QR gen
     ws.on('CB:iq,type:set,pair-device', async (stanza) => {
         const iq = {
             tag: 'iq',
             attrs: {
-                to: S_WHATSAPP_NET,
+                to: WABinary_1.S_WHATSAPP_NET,
                 type: 'result',
-                id: stanza.attrs.id
+                id: stanza.attrs.id,
             }
         };
         await sendNode(iq);
-        const pairDeviceNode = getBinaryNodeChild(stanza, 'pair-device');
-        const refNodes = getBinaryNodeChildren(pairDeviceNode, 'ref');
+        const pairDeviceNode = (0, WABinary_1.getBinaryNodeChild)(stanza, 'pair-device');
+        const refNodes = (0, WABinary_1.getBinaryNodeChildren)(pairDeviceNode, 'ref');
         const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString('base64');
         const identityKeyB64 = Buffer.from(creds.signedIdentityKey.public).toString('base64');
         const advB64 = creds.advSecretKey;
@@ -468,7 +489,7 @@ export const makeSocket = (config) => {
             }
             const refNode = refNodes.shift();
             if (!refNode) {
-                end(new Boom('QR refs attempts ended', { statusCode: DisconnectReason.timedOut }));
+                end(new boom_1.Boom('QR refs attempts ended', { statusCode: Types_1.DisconnectReason.timedOut }));
                 return;
             }
             const ref = refNode.content.toString('utf-8');
@@ -484,7 +505,7 @@ export const makeSocket = (config) => {
     ws.on('CB:iq,,pair-success', async (stanza) => {
         logger.debug('pair success recv');
         try {
-            const { reply, creds: updatedCreds } = configureSuccessfulPairing(stanza, creds);
+            const { reply, creds: updatedCreds } = (0, Utils_1.configureSuccessfulPairing)(stanza, creds);
             logger.info({ me: updatedCreds.me, platform: updatedCreds.platform }, 'pairing configured successfully, expect to restart the connection...');
             ev.emit('creds.update', updatedCreds);
             ev.emit('connection.update', { isNewLogin: true, qr: undefined });
@@ -497,25 +518,31 @@ export const makeSocket = (config) => {
     });
     // login complete
     ws.on('CB:success', async (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' });
+        try {
+            await uploadPreKeysToServerIfRequired();
+            await sendPassiveIq('active');
+            logger.info('opened connection to WA');
+            clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
+            ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
+            ev.emit('connection.update', { connection: 'open' });
+        }
+        catch (err) {
+            logger.error({ err }, 'error opening connection');
+            end(err);
+        }
     });
     ws.on('CB:stream:error', (node) => {
         logger.error({ node }, 'stream errored out');
-        const { reason, statusCode } = getErrorCodeFromStreamError(node);
-        end(new Boom(`Stream Errored (${reason})`, { statusCode, data: node }));
+        const { reason, statusCode } = (0, Utils_1.getErrorCodeFromStreamError)(node);
+        end(new boom_1.Boom(`Stream Errored (${reason})`, { statusCode, data: node }));
     });
     // stream fail, possible logout
     ws.on('CB:failure', (node) => {
         const reason = +(node.attrs.reason || 500);
-        end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
+        end(new boom_1.Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
     });
     ws.on('CB:ib,,downgrade_webclient', () => {
-        end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
+        end(new boom_1.Boom('Multi-device beta not joined', { statusCode: Types_1.DisconnectReason.multideviceMismatch }));
     });
     ws.on('CB:ib,,offline_preview', (node) => {
         logger.info('offline preview received', JSON.stringify(node));
@@ -526,16 +553,17 @@ export const makeSocket = (config) => {
         });
     });
     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);
+        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);
             ev.emit('creds.update', authState.creds);
         }
     });
     let didStartBuffer = false;
     process.nextTick(() => {
-        if (creds.me?.id) {
+        var _a;
+        if ((_a = creds.me) === null || _a === void 0 ? void 0 : _a.id) {
             // start buffering important events
             // if we're logged in
             ev.buffer();
@@ -545,8 +573,8 @@ export const makeSocket = (config) => {
     });
     // called when all offline notifs are handled
     ws.on('CB:ib,,offline', (node) => {
-        const child = getBinaryNodeChild(node, 'offline');
-        const offlineNotifs = +(child?.attrs.count || 0);
+        const child = (0, WABinary_1.getBinaryNodeChild)(node, 'offline');
+        const offlineNotifs = +((child === null || child === void 0 ? void 0 : child.attrs.count) || 0);
         logger.info(`handled ${offlineNotifs} offline messages/notifications`);
         if (didStartBuffer) {
             ev.flush();
@@ -556,19 +584,24 @@ export const makeSocket = (config) => {
     });
     // update credentials when required
     ev.on('creds.update', update => {
-        const name = update.me?.name;
+        var _a, _b;
+        const name = (_a = update.me) === null || _a === void 0 ? void 0 : _a.name;
         // if name has just been received
-        if (creds.me?.name !== name) {
+        if (((_b = creds.me) === null || _b === void 0 ? void 0 : _b.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);
+    }
     return {
         type: 'md',
         ws,
@@ -591,17 +624,17 @@ export const makeSocket = (config) => {
         uploadPreKeysToServerIfRequired,
         requestPairingCode,
         /** Waits for the connection to WA to reach a state */
-        waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
-        sendWAMBuffer
+        waitForConnectionUpdate: (0, Utils_1.bindWaitForConnectionUpdate)(ev),
+        sendWAMBuffer,
     };
 };
+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(`WebSocket Error (${error?.message})`, { statusCode: getCodeFromWSError(error), data: 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 }));
     };
 }
-//# sourceMappingURL=socket.js.map