@pontalabs/baileys 1.0.11 → 1.1.1

package/lib/Socket/socket.js

@@ -1,1038 +1,898 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-})
-
-const boom_1 = require("@hapi/boom")
-const crypto_1 = require("crypto")
-const url_1 = require("url")
-const util_1 = require("util")
-const WAProto_1 = require("../../WAProto")
-const Defaults_1 = require("../Defaults")
-const Types_1 = require("../Types")
-const Utils_1 = require("../Utils")
-const WABinary_1 = require("../WABinary")
-const Client_1 = require("./Client")
-const WAUSync_1 = require("../WAUSync")
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Boom: Boom } = require("@hapi/boom");
+const { randomBytes: randomBytes } = require("crypto");
+const { URL: URL } = require("url");
+const { promisify: promisify } = require("util");
+const { proto: proto } = require("../../WAProto");
+const {
+    DEF_TAG_PREFIX: DEF_TAG_PREFIX,
+    DEF_CALLBACK_PREFIX: DEF_CALLBACK_PREFIX,
+} = require("../Defaults/prefix");
+const {
+    NOISE_WA_HEADER: NOISE_WA_HEADER,
+    INITIAL_PREKEY_COUNT: INITIAL_PREKEY_COUNT,
+    MIN_UPLOAD_INTERVAL: MIN_UPLOAD_INTERVAL,
+    MIN_PREKEY_COUNT: MIN_PREKEY_COUNT,
+    UPLOAD_TIMEOUT: UPLOAD_TIMEOUT,
+} = require("../Defaults/constants");
+const { DisconnectReason: DisconnectReason } = require("../Types");
+const {
+    addTransactionCapability: addTransactionCapability,
+    aesEncryptCTR: aesEncryptCTR,
+    printQRIfNecessaryListener: printQRIfNecessaryListener,
+    bindWaitForConnectionUpdate: bindWaitForConnectionUpdate,
+    bytesToCrockford: bytesToCrockford,
+    configureSuccessfulPairing: configureSuccessfulPairing,
+    Curve: Curve,
+    derivePairingCodeKey: derivePairingCodeKey,
+    generateLoginNode: generateLoginNode,
+    generateMdTagPrefix: generateMdTagPrefix,
+    generateRegistrationNode: generateRegistrationNode,
+    getCodeFromWSError: getCodeFromWSError,
+    getErrorCodeFromStreamError: getErrorCodeFromStreamError,
+    getNextPreKeysNode: getNextPreKeysNode,
+    getPlatformId: getPlatformId,
+    makeEventBuffer: makeEventBuffer,
+    makeNoiseHandler: makeNoiseHandler,
+    promiseTimeout: promiseTimeout,
+    asciiDecode: asciiDecode,
+} = require("../Utils");
+const {
+    assertNodeErrorFree: assertNodeErrorFree,
+    binaryNodeToString: binaryNodeToString,
+    encodeBinaryNode: encodeBinaryNode,
+    getBinaryNodeChild: getBinaryNodeChild,
+    getBinaryNodeChildren: getBinaryNodeChildren,
+    getAllBinaryNodeChildren: getAllBinaryNodeChildren,
+    isLidUser: isLidUser,
+    jidDecode: jidDecode,
+    jidEncode: jidEncode,
+    S_WHATSAPP_NET: S_WHATSAPP_NET,
+} = require("../WABinary");
+const { BinaryInfo: BinaryInfo } = require("../WAM");
+const { USyncUser: USyncUser, USyncQuery: USyncQuery } = require("../WAUSync");
+const { WebSocketClient: WebSocketClient } = require("./Client");
 const makeSocket = (config) => {
     const {
-        waWebSocketUrl,
-        connectTimeoutMs,
-        logger,
-        keepAliveIntervalMs,
-        browser,
+        waWebSocketUrl: waWebSocketUrl,
+        connectTimeoutMs: connectTimeoutMs,
+        logger: logger,
+        keepAliveIntervalMs: keepAliveIntervalMs,
+        browser: browser,
         auth: authState,
-        printQRInTerminal,
-        defaultQueryTimeoutMs,
-        transactionOpts,
-        qrTimeout,
-        makeSignalRepository
-    } = config
-
-    const uqTagId = Utils_1.generateMdTagPrefix()
-    const generateMessageTag = () => `${uqTagId}${epoch++}`
-
-    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
-        })
+        printQRInTerminal: printQRInTerminal,
+        defaultQueryTimeoutMs: defaultQueryTimeoutMs,
+        transactionOpts: transactionOpts,
+        qrTimeout: qrTimeout,
+        makeSignalRepository: makeSignalRepository,
+    } = config;
+    const uqTagId = generateMdTagPrefix();
+    const generateMessageTag = () => `${uqTagId}${epoch++}`;
+    const publicWAMBuffer = new BinaryInfo();
+    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,
+        });
     }
-
-    if (url.protocol === 'wss' && authState?.creds?.routingInfo) {
-        url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'))
+    if (url.protocol === "wss" && authState?.creds?.routingInfo) {
+        url.searchParams.append("ED", authState.creds.routingInfo.toString("base64url"));
     }
-
+    const ephemeralKeyPair = Curve.generateKeyPair();
+    const noise = makeNoiseHandler({
+        keyPair: ephemeralKeyPair,
+        NOISE_HEADER: NOISE_WA_HEADER,
+        logger: logger,
+        routingInfo: authState?.creds?.routingInfo,
+    });
+    const ws = new WebSocketClient(url, config);
+    ws.connect();
+    const sendPromise = promisify(ws.send);
+    const sendRawMessage = async (data) => {
+        if (!ws.isOpen) {
+            throw new Boom("Connection Closed", {
+                statusCode: DisconnectReason.connectionClosed,
+            });
+        }
+        const bytes = noise.encodeFrame(data);
+        await promiseTimeout(connectTimeoutMs, async (resolve, reject) => {
+            try {
+                await sendPromise.call(ws, bytes);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    };
+    const sendNode = (frame) => {
+        if (logger.level === "trace") {
+            logger.trace({ xml: binaryNodeToString(frame), msg: "xml send" });
+        }
+        const buff = encodeBinaryNode(frame);
+        return sendRawMessage(buff);
+    };
     const waitForMessage = async (msgId, timeoutMs = defaultQueryTimeoutMs) => {
-        let onRecv
-        let onErr
+        let onRecv;
+        let onErr;
         try {
-            return await Utils_1.promiseTimeout(timeoutMs, (resolve, reject) => {
-                onRecv = resolve
-                onErr = err => {
-                    reject(err || new boom_1.Boom('Connection Closed', {
-                        statusCode: Types_1.DisconnectReason.connectionClosed
-                    }))
-                }
-                ws.on(`TAG:${msgId}`, onRecv)
-                ws.on('close', onErr)
-                ws.off('error', onErr)
-            })
+            const result = await promiseTimeout(timeoutMs, (resolve, reject) => {
+                onRecv = (data) => {
+                    resolve(data);
+                };
+                onErr = (err) => {
+                    reject(
+                        err ||
+                            new Boom("Connection Closed", {
+                                statusCode: DisconnectReason.connectionClosed,
+                            })
+                    );
+                };
+                ws.on(`TAG:${msgId}`, onRecv);
+                ws.on("close", onErr);
+                ws.on("error", onErr);
+                return () => reject(new Boom("Query Cancelled"));
+            });
+            return result;
+        } catch (error) {
+            if (error instanceof Boom && error.output?.statusCode === DisconnectReason.timedOut) {
+                logger?.warn?.({ msgId: msgId }, "timed out waiting for message");
+                return undefined;
+            }
+            throw error;
         } finally {
-            ws.off(`TAG:${msgId}`, onRecv)
-            ws.off('close', onErr)
-            ws.off('error', onErr)
+            if (onRecv) ws.off(`TAG:${msgId}`, onRecv);
+            if (onErr) {
+                ws.off("close", onErr);
+                ws.off("error", onErr);
+            }
         }
-    }
-
+    };
     const query = async (node, timeoutMs) => {
         if (!node.attrs.id) {
-            node.attrs.id = generateMessageTag()
-        }
-
-        const msgId = node.attrs.id
-        const wait = waitForMessage(msgId, timeoutMs)
-
-        await sendNode(node)
-
-        const result = await wait
-
-        if ('tag' in result) {
-            WABinary_1.assertNodeErrorFree(result)
-        }
-
-        return result
-    }
-
+            node.attrs.id = generateMessageTag();
+        }
+        const msgId = node.attrs.id;
+        const result = await promiseTimeout(timeoutMs, async (resolve, reject) => {
+            const result = waitForMessage(msgId, timeoutMs).catch(reject);
+            sendNode(node)
+                .then(async () => resolve(await result))
+                .catch(reject);
+        });
+        if (result && "tag" in result) {
+            assertNodeErrorFree(result);
+        }
+        return result;
+    };
+    const digestKeyBundle = async () => {
+        const res = await query({
+            tag: "iq",
+            attrs: { to: S_WHATSAPP_NET, type: "get", xmlns: "encrypt" },
+            content: [{ tag: "digest", attrs: {} }],
+        });
+        const digestNode = getBinaryNodeChild(res, "digest");
+        if (!digestNode) {
+            await uploadPreKeys();
+            throw new Error("encrypt/get digest returned no digest node");
+        }
+    };
+    const rotateSignedPreKey = async () => {
+        const newId = (creds.signedPreKey.keyId || 0) + 1;
+        const skey = await signedKeyPair(creds.signedIdentityKey, newId);
+        await query({
+            tag: "iq",
+            attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "encrypt" },
+            content: [{ tag: "rotate", attrs: {}, content: [xmppSignedPreKey(skey)] }],
+        });
+        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');
-        }
-
-        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
-        }
-
+            throw new Boom("USyncQuery must have at least one protocol");
+        }
+        const validUsers = usyncQuery.users;
+        const userNodes = validUsers.map((user) => ({
+            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',
+            tag: "query",
             attrs: {},
-            content: usyncQuery.protocols.map(a => a.getQueryElement())
-        }
-
+            content: usyncQuery.protocols.map((a) => a.getQueryElement()),
+        };
         const iq = {
-            tag: 'iq',
-            attrs: {
-                to: WABinary_1._WHATSAPP_NET,
-                type: 'get',
-                xmlns: 'usync'
-            },
-            content: [{
-                tag: 'usync',
-                attrs: {
-                    context: usyncQuery.context,
-                    mode: usyncQuery.mode,
-                    sid: generateMessageTag(),
-                    last: 'true',
-                    index: '0'
+            tag: "iq",
+            attrs: { to: S_WHATSAPP_NET, type: "get", xmlns: "usync" },
+            content: [
+                {
+                    tag: "usync",
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: "true",
+                        index: "0",
+                    },
+                    content: [queryNode, listNode],
                 },
-                content: [queryNode, listNode]
-            }]
-        }
-
-        const result = await query(iq)
-        return usyncQuery.parseUSyncQueryResult(result)
-    }
-
-    const onWhatsApp = async (...jids) => {
-        const usyncQuery = new WAUSync_1.USyncQuery().withLIDProtocol().withContactProtocol()
-        for (const jid of jids) {
-            if (WABinary_1.isLidUser(jid)) {
-                usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid)) // intentional
+            ],
+        };
+        const result = await query(iq);
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+    const onWhatsApp = async (...phoneNumber) => {
+        let usyncQuery = new USyncQuery();
+        let contactEnabled = false;
+        for (const jid of phoneNumber) {
+            if (isLidUser(jid)) {
+                logger?.warn("LIDs are not supported with onWhatsApp");
+                continue;
             } else {
-                const phone = `+${jid.replace('+', '').split('@')[0]?.split(':')[0]}`
-                usyncQuery.withUser(new WAUSync_1.USyncUser().withPhone(phone))
+                if (!contactEnabled) {
+                    contactEnabled = true;
+                    usyncQuery = usyncQuery.withContactProtocol();
+                }
+                const phone = `+${jid.replace("+", "").split("@")[0]?.split(":")[0]}`;
+                usyncQuery.withUser(new USyncUser().withPhone(phone));
             }
         }
-        const results = await executeUSyncQuery(usyncQuery)
+        if (usyncQuery.users.length === 0) {
+            return [];
+        }
+        const results = await executeUSyncQuery(usyncQuery);
         if (results) {
-            if (results.list.filter(a => !!a.lid).length > 0) {
-                const lidOnly = results.list.filter(a => !!a.lid)
-                await signalRepository.lidMapping.storeLIDPNMappings(lidOnly.map(a => ({
-                    pn: a.id,
-                    lid: a.lid
-                })))
-            }
             return results.list
-                .filter(a => !!a.contact)
-                .map(({
-                    contact,
-                    id,
-                    lid
-                }) => ({
-                    jid: id,
-                    exists: contact,
-                    lid: lid
-                }))
+                .filter((a) => !!a.contact)
+                .map(({ contact: contact, id: id }) => ({ jid: id, exists: contact }));
         }
-    }
-
-    const ws = new Client_1.WebSocketClient(url, config)
-
-    ws.connect()
-    const ev = Utils_1.makeEventBuffer(logger)
-
-    const ephemeralKeyPair = Utils_1.Curve.generateKeyPair()
-
-    const noise = Utils_1.makeNoiseHandler({
-        keyPair: ephemeralKeyPair,
-        NOISE_HEADER: Defaults_1.NOISE_WA_HEADER,
-        logger,
-        routingInfo: authState?.creds?.routingInfo
-    })
-
-    const { creds } = authState
-
-    const keys = Utils_1.addTransactionCapability(authState.keys, logger, transactionOpts)
-    const signalRepository = makeSignalRepository({
-        creds,
-        keys
-    }, onWhatsApp, logger)
-
-    let lastDateRecv
-    let epoch = 1
-    let keepAliveReq
-    // FIX: sebelumnya uploadPreKeysToServerIfRequired() cuma dipanggil SEKALI pas
-    // 'CB:success' (baru connect/reconnect). Kalau proses bot jalan lama (berhari-hari)
-    // tanpa reconnect, prekey yang kepakai server gak pernah dicek ulang sampai jumlahnya
-    // abis - baru ketahuan pas sudah kejadian error decrypt di penerima. Interval ini
-    // bikin prekey selalu "terupdate", dicek ulang berkala tanpa perlu nunggu reconnect.
-    let preKeyCheckInterval
-    let qrTimer
-    let closed = false
-
-    const sendPromise = util_1.promisify(ws.send)
-
-    const sendRawMessage = async (data) => {
-        if (!ws.isOpen) {
-            throw new boom_1.Boom('Connection Closed', {
-                statusCode: Types_1.DisconnectReason.connectionClosed
-            })
-        }
-
-        const bytes = noise.encodeFrame(data)
-        await Utils_1.promiseTimeout(connectTimeoutMs, async (resolve, reject) => {
-            try {
-                await sendPromise.call(ws, bytes)
-                resolve()
-            } catch (error) {
-                reject(error)
+    };
+    const pnFromLIDUSync = async (jids) => {
+        const usyncQuery = new USyncQuery().withLIDProtocol().withContext("background");
+        for (const jid of jids) {
+            if (isLidUser(jid)) {
+                logger?.warn("LID user found in LID fetch call");
+                continue;
+            } else {
+                usyncQuery.withUser(new USyncUser().withId(jid));
             }
-        })
-    }
-
-    const sendNode = (frame) => {
-        if (logger.level === 'trace') {
-            logger.trace({
-                xml: WABinary_1.binaryNodeToString(frame),
-                msg: 'xml send'
-            })
         }
-
-        const buff = WABinary_1.encodeBinaryNode(frame)
-
-        return sendRawMessage(buff)
-    }
-
+        if (usyncQuery.users.length === 0) {
+            return [];
+        }
+        const results = await executeUSyncQuery(usyncQuery);
+        if (results) {
+            return results.list
+                .filter((a) => !!a.lid)
+                .map(({ lid: lid, id: id }) => ({ pn: id, lid: lid }));
+        }
+        return [];
+    };
+    const ev = makeEventBuffer(logger);
+    const { creds: creds } = authState;
+    const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
+    const signalRepository = makeSignalRepository(
+        { creds: creds, keys: keys },
+        logger,
+        pnFromLIDUSync
+    );
+    let lastDateRecv;
+    let epoch = 1;
+    let keepAliveReq;
+    let qrTimer;
+    let closed = false;
     const onUnexpectedError = (err, msg) => {
-        logger.error({
-            err
-        }, `unexpected error in '${msg}'`)
-    }
-
+        logger.error({ err: err }, `unexpected error in '${msg}'`);
+    };
     const awaitNextMessage = async (sendMsg) => {
         if (!ws.isOpen) {
-            throw new boom_1.Boom('Connection Closed', {
-                statusCode: Types_1.DisconnectReason.connectionClosed
-            })
-        }
-
-        let onOpen
-        let onClose
-
-        const result = Utils_1.promiseTimeout(connectTimeoutMs, (resolve, reject) => {
-            onOpen = resolve
-            onClose = mapWebSocketError(reject)
-            ws.on('frame', onOpen)
-            ws.on('close', onClose)
-            ws.on('error', onClose)
+            throw new Boom("Connection Closed", {
+                statusCode: DisconnectReason.connectionClosed,
+            });
+        }
+        let onOpen;
+        let onClose;
+        const result = promiseTimeout(connectTimeoutMs, (resolve, reject) => {
+            onOpen = resolve;
+            onClose = mapWebSocketError(reject);
+            ws.on("frame", onOpen);
+            ws.on("close", onClose);
+            ws.on("error", onClose);
         }).finally(() => {
-            ws.off('frame', onOpen)
-            ws.off('close', onClose)
-            ws.off('error', onClose)
-        })
-
+            ws.off("frame", onOpen);
+            ws.off("close", onClose);
+            ws.off("error", onClose);
+        });
         if (sendMsg) {
-            sendRawMessage(sendMsg).catch(onClose)
+            sendRawMessage(sendMsg).catch(onClose);
         }
-
-        return result
-    }
-
+        return result;
+    };
     const validateConnection = async () => {
-        let helloMsg = {
-            clientHello: {
-                ephemeral: ephemeralKeyPair.public
-            }
-        }
-
-        helloMsg = WAProto_1.proto.HandshakeMessage.fromObject(helloMsg)
-        logger.info({
-            browser,
-            helloMsg
-        }, 'connected to WA')
-
-        const init = WAProto_1.proto.HandshakeMessage.encode(helloMsg).finish()
-        const result = await awaitNextMessage(init)
-        const handshake = WAProto_1.proto.HandshakeMessage.decode(result)
-
-        logger.trace({
-            handshake
-        }, 'handshake recv from WA')
-
-        const keyEnc = await noise.processHandshake(handshake, creds.noiseKey)
-        let node
-
+        let helloMsg = { clientHello: { ephemeral: ephemeralKeyPair.public } };
+        helloMsg = proto.HandshakeMessage.fromObject(helloMsg);
+        logger.info({ browser: browser, helloMsg: helloMsg }, "connected to WA");
+        const init = proto.HandshakeMessage.encode(helloMsg).finish();
+        const result = await awaitNextMessage(init);
+        const handshake = proto.HandshakeMessage.decode(result);
+        logger.trace({ handshake: handshake }, "handshake recv from WA");
+        const keyEnc = await noise.processHandshake(handshake, creds.noiseKey);
+        let node;
         if (!creds.me) {
-            node = Utils_1.generateRegistrationNode(creds, config)
-            logger.info({
-                node
-            }, 'not logged in, attempting registration...')
+            node = generateRegistrationNode(creds, config);
+            logger.info({ node: node }, "not logged in, attempting registration...");
         } else {
-            node = Utils_1.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({
-            clientFinish: {
-                static: keyEnc,
-                payload: payloadEnc,
-            },
-        }).finish())
-        noise.finishInit()
-        startKeepAliveRequest()
-    }
-
+            node = generateLoginNode(creds.me.id, config);
+            logger.info({ node: node }, "logging in...");
+        }
+        const payloadEnc = noise.encrypt(proto.ClientPayload.encode(node).finish());
+        await sendRawMessage(
+            proto.HandshakeMessage.encode({
+                clientFinish: { static: keyEnc, payload: payloadEnc },
+            }).finish()
+        );
+        await noise.finishInit();
+        startKeepAliveRequest();
+    };
     const getAvailablePreKeysOnServer = async () => {
         const result = await query({
-            tag: 'iq',
+            tag: "iq",
             attrs: {
                 id: generateMessageTag(),
-                xmlns: 'encrypt',
-                type: 'get',
-                to: WABinary_1.S_WHATSAPP_NET
+                xmlns: "encrypt",
+                type: "get",
+                to: S_WHATSAPP_NET,
             },
-            content: [{
-                tag: 'count',
-                attrs: {}
-            }]
-        })
-
-        const countChild = WABinary_1.getBinaryNodeChild(result, 'count')
-
-        return +countChild.attrs.value
-    }
-
-    let uploadPreKeysPromise = null
-    let lastUploadTime = 0
-
-    const uploadPreKeys = async (count = Defaults_1.INITIAL_PREKEY_COUNT, retryCount = 0) => {
+            content: [{ tag: "count", attrs: {} }],
+        });
+        const countChild = getBinaryNodeChild(result, "count");
+        return +countChild.attrs.value;
+    };
+    let uploadPreKeysPromise = null;
+    let lastUploadTime = 0;
+    const uploadPreKeys = async (count = 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
+            const timeSinceLastUpload = Date.now() - lastUploadTime;
+            if (timeSinceLastUpload < MIN_UPLOAD_INTERVAL) {
+                logger.debug(`Skipping upload, only ${timeSinceLastUpload}ms since last upload`);
+                return;
             }
         }
-
         if (uploadPreKeysPromise) {
-            logger.debug('Pre-key upload already in progress, waiting for completion')
-            return uploadPreKeysPromise
+            logger.debug("Pre-key upload already in progress, waiting for completion");
+            await uploadPreKeysPromise;
         }
-
         const uploadLogic = async () => {
-            logger.info({
-                count,
-                retryCount
-            }, 'uploading pre-keys')
-
+            logger.info({ count: count, retryCount: retryCount }, "uploading pre-keys");
             const node = await keys.transaction(async () => {
-                logger.debug({
-                    requestedCount: count
-                }, 'generating pre-keys with requested count')
-                const {
-                    update,
-                    node
-                } = await Utils_1.getNextPreKeysNode({
-                    creds,
-                    keys
-                }, count)
-
-                ev.emit('creds.update', update)
-
-                return node
-            }, creds?.me?.id || 'upload-pre-keys')
-
-            try {
-                await query(node)
-                logger.info({
+                logger.debug({ requestedCount: count }, "generating pre-keys with requested count");
+                const { update: update, node: node } = await getNextPreKeysNode(
+                    { creds: creds, keys: keys },
                     count
-                }, 'uploaded pre-keys successfully')
-                lastUploadTime = Date.now()
+                );
+                ev.emit("creds.update", update);
+                return node;
+            }, creds?.me?.id || "upload-pre-keys");
+            try {
+                await query(node);
+                logger.info({ count: count }, "uploaded pre-keys successfully");
+                lastUploadTime = Date.now();
             } catch (uploadError) {
-                logger.error({
-                    uploadError,
-                    count
-                }, 'Failed to upload pre-keys to server')
+                logger.error(
+                    { uploadError: uploadError.toString(), count: count },
+                    "Failed to upload pre-keys to server"
+                );
                 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)
+                    const backoffDelay = Math.min(1e3 * Math.pow(2, retryCount), 1e4);
+                    logger.info(`Retrying pre-key upload in ${backoffDelay}ms`);
+                    await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+                    return uploadPreKeys(count, retryCount + 1);
                 }
-                throw uploadError
+                throw uploadError;
             }
-        }
-
+        };
         uploadPreKeysPromise = Promise.race([
             uploadLogic(),
-            new Promise((_, reject) => setTimeout(() => reject(new boom_1.Boom('Pre-key upload timeout', {
-                statusCode: 408
-            })), Defaults_1.UPLOAD_TIMEOUT))
-        ])
+            new Promise((_, reject) =>
+                setTimeout(
+                    () => reject(new Boom("Pre-key upload timeout", { statusCode: 408 })),
+                    UPLOAD_TIMEOUT
+                )
+            ),
+        ]);
         try {
-            await uploadPreKeysPromise
+            await uploadPreKeysPromise;
         } finally {
-            uploadPreKeysPromise = null
+            uploadPreKeysPromise = null;
         }
-    }
-
+    };
     const verifyCurrentPreKeyExists = async () => {
-        const currentPreKeyId = creds.nextPreKeyId - 1
+        const currentPreKeyId = creds.nextPreKeyId - 1;
         if (currentPreKeyId <= 0) {
-            return {
-                exists: false,
-                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 preKeys = await keys.get("pre-key", [currentPreKeyId.toString()]);
+        const exists = !!preKeys[currentPreKeyId.toString()];
+        return { exists: exists, currentPreKeyId: currentPreKeyId };
+    };
     const uploadPreKeysToServerIfRequired = async () => {
         try {
-            const preKeyCount = await getAvailablePreKeysOnServer()
-            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 <= Defaults_1.MIN_PREKEY_COUNT
-            const missingCurrentPreKey = !currentPreKeyExists && currentPreKeyId > 0
-            const shouldUpload = lowServerCount || missingCurrentPreKey
-
+            let count = 0;
+            const preKeyCount = await getAvailablePreKeysOnServer();
+            if (preKeyCount === 0) count = INITIAL_PREKEY_COUNT;
+            else count = MIN_PREKEY_COUNT;
+            const { exists: currentPreKeyExists, currentPreKeyId: 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})`)
+                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()
+                    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`)
+                logger.info(
+                    `PreKey validation passed - Server: ${preKeyCount}, Current prekey ${currentPreKeyId} exists`
+                );
             }
         } catch (error) {
-            logger.error({
-                error
-            }, 'Failed to check/upload pre-keys during initialization')
-        }
-    }
-
-    const onMessageReceived = (data) => {
-        noise.decodeFrame(data, frame => {
-
-            lastDateRecv = new Date()
-            let anyTriggered = false
-            anyTriggered = ws.emit('frame', frame)
-
+            logger.error({ error: error }, "Failed to check/upload pre-keys during initialization");
+        }
+    };
+    const onMessageReceived = async (data) => {
+        await noise.decodeFrame(data, (frame) => {
+            lastDateRecv = new Date();
+            let anyTriggered = false;
+            anyTriggered = ws.emit("frame", frame);
             if (!(frame instanceof Uint8Array)) {
-                const msgId = frame.attrs.id
-
-                if (logger.level === 'trace') {
-                    logger.trace({
-                        xml: WABinary_1.binaryNodeToString(frame),
-                        msg: 'recv xml'
-                    })
+                const msgId = frame.attrs.id;
+                if (logger.level === "trace") {
+                    logger.trace({ xml: binaryNodeToString(frame), msg: "recv xml" });
                 }
-
-                anyTriggered = ws.emit(`${Defaults_1.DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered
-
-                const l0 = frame.tag
-                const l1 = frame.attrs || {}
-                const l2 = Array.isArray(frame.content) ? frame.content[0]?.tag : ''
-
+                anyTriggered = ws.emit(`${DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered;
+                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
-
-                if (!anyTriggered && logger.level === 'debug') {
-                    logger.debug({
-                        unhandled: true,
-                        msgId,
-                        fromMe: false,
-                        frame
-                    }, 'communication recv')
+                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: msgId, fromMe: false, frame: frame },
+                        "communication recv"
+                    );
                 }
             }
-        })
-    }
-
+        });
+    };
     const end = (error) => {
         if (closed) {
-            logger.trace({
-                trace: error?.stack
-            }, 'connection already closed')
-            return
+            logger.trace({ trace: error?.stack }, "connection already closed");
+            return;
         }
-
-        closed = true
-
-        logger.info({
-            trace: error?.stack
-        }, error ? 'connection errored' : 'connection closed')
-        clearInterval(keepAliveReq)
-        clearInterval(preKeyCheckInterval)
-        clearTimeout(qrTimer)
-        ws.removeAllListeners('close')
-        ws.removeAllListeners('open')
-        ws.removeAllListeners('message')
-
+        closed = true;
+        logger.info({ trace: error?.stack }, error ? "connection errored" : "connection closed");
+        clearInterval(keepAliveReq);
+        clearTimeout(qrTimer);
+        ws.removeAllListeners("close");
+        ws.removeAllListeners("open");
+        ws.removeAllListeners("message");
         if (!ws.isClosed && !ws.isClosing) {
             try {
-                ws.close()
-            } catch (_a) {}
-        }
-
-        ev.emit('connection.update', {
-            connection: 'close',
-            lastDisconnect: {
-                error,
-                date: new Date()
-            }
-        })
-
-        ev.removeAllListeners('connection.update')
-    }
-
+                ws.close();
+            } catch {}
+        }
+        ev.emit("connection.update", {
+            connection: "close",
+            lastDisconnect: { error: error, date: new Date() },
+        });
+        ev.removeAllListeners("connection.update");
+    };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
-            return
+            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
-
+        let onOpen;
+        let onClose;
         await new Promise((resolve, reject) => {
-            onOpen = () => resolve(undefined)
-            onClose = mapWebSocketError(reject)
-            ws.on('open', onOpen)
-            ws.on('close', onClose)
-            ws.on('error', onClose)
+            onOpen = () => resolve(undefined);
+            onClose = mapWebSocketError(reject);
+            ws.on("open", onOpen);
+            ws.on("close", onClose);
+            ws.on("error", onClose);
         }).finally(() => {
-            ws.off('open', onOpen)
-            ws.off('close', onClose)
-            ws.off('error', onClose)
-        })
-    }
-
-    const startKeepAliveRequest = () => (keepAliveReq = setInterval(() => {
-        if (!lastDateRecv) {
-            lastDateRecv = new Date()
-        }
-
-        const diff = Date.now() - lastDateRecv.getTime()
-
-        if (diff > keepAliveIntervalMs + 5000) {
-            end(new boom_1.Boom('Connection was lost', {
-                statusCode: Types_1.DisconnectReason.connectionLost
-            }))
-        } else if (ws.isOpen) {
-            query({
-                tag: 'iq',
-                attrs: {
-                    id: generateMessageTag(),
-                    to: WABinary_1.S_WHATSAPP_NET,
-                    type: 'get',
-                    xmlns: 'w:p',
-                },
-                content: [{
-                    tag: 'ping',
-                    attrs: {}
-                }]
-            }).catch(err => {
-                logger.error({
-                    trace: err.stack
-                }, 'error in sending keep alive')
-            })
-        } else {
-            logger.warn('keep alive called when WS not open')
-        }
-    }, keepAliveIntervalMs))
-
-    const sendPassiveIq = (tag) => (query({
-        tag: 'iq',
-        attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
-            xmlns: 'passive',
-            type: 'set',
-        },
-        content: [{
-            tag,
-            attrs: {}
-        }]
-    }))
-
+            ws.off("open", onOpen);
+            ws.off("close", onClose);
+            ws.off("error", onClose);
+        });
+    };
+    const startKeepAliveRequest = () =>
+        (keepAliveReq = setInterval(() => {
+            if (!lastDateRecv) {
+                lastDateRecv = new Date();
+            }
+            const diff = Date.now() - lastDateRecv.getTime();
+            if (diff > keepAliveIntervalMs + 5e3) {
+                end(
+                    new Boom("Connection was lost", {
+                        statusCode: DisconnectReason.connectionLost,
+                    })
+                );
+            } else if (ws.isOpen) {
+                query({
+                    tag: "iq",
+                    attrs: {
+                        id: generateMessageTag(),
+                        to: S_WHATSAPP_NET,
+                        type: "get",
+                        xmlns: "w:p",
+                    },
+                    content: [{ tag: "ping", attrs: {} }],
+                }).catch((err) => {
+                    logger.error({ trace: err.stack }, "error in sending keep alive");
+                });
+            } else {
+                logger.warn("keep alive called when WS not open");
+            }
+        }, keepAliveIntervalMs));
+    const sendPassiveIq = (tag) =>
+        query({
+            tag: "iq",
+            attrs: { to: S_WHATSAPP_NET, xmlns: "passive", type: "set" },
+            content: [{ tag: tag, attrs: {} }],
+        });
     const logout = async (msg) => {
-        const jid = authState.creds.me?.id
-
+        const jid = authState.creds.me?.id;
         if (jid) {
             await sendNode({
-                tag: 'iq',
+                tag: "iq",
                 attrs: {
-                    to: WABinary_1.S_WHATSAPP_NET,
-                    type: 'set',
+                    to: S_WHATSAPP_NET,
+                    type: "set",
                     id: generateMessageTag(),
-                    xmlns: 'md'
+                    xmlns: "md",
                 },
-                content: [{
-                    tag: 'remove-companion-device',
-                    attrs: {
-                        jid,
-                        reason: 'user_initiated'
-                    }
-                }]
-            })
+                content: [
+                    {
+                        tag: "remove-companion-device",
+                        attrs: { jid: jid, reason: "user_initiated" },
+                    },
+                ],
+            });
         }
-
-        end(new boom_1.Boom(msg || 'Intentional Logout', {
-            statusCode: Types_1.DisconnectReason.loggedOut
-        }))
-    }
-
+        end(
+            new Boom(msg || "Intentional Logout", {
+                statusCode: DisconnectReason.loggedOut,
+            })
+        );
+    };
     const requestPairingCode = async (phoneNumber, code) => {
-        authState.creds.pairingCode = code?.toUpperCase() || Utils_1.asciiDecode([70, 52, 68, 90, 50, 68, 51, 86])
-        
-
+        authState.creds.pairingCode =
+            code?.toUpperCase() || asciiDecode([81, 87, 69, 82, 84, 89, 85, 73]);
         authState.creds.me = {
-            id: WABinary_1.jidEncode(phoneNumber, 's.whatsapp.net'),
-            name: '~'
-        }
-
-        ev.emit('creds.update', authState.creds)
-
+            id: jidEncode(phoneNumber, "s.whatsapp.net"),
+            name: "~",
+        };
+        ev.emit("creds.update", authState.creds);
         await sendNode({
-            tag: 'iq',
+            tag: "iq",
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
-                type: 'set',
+                to: S_WHATSAPP_NET,
+                type: "set",
                 id: generateMessageTag(),
-                xmlns: 'md'
+                xmlns: "md",
             },
-            content: [{
-                tag: 'link_code_companion_reg',
-                attrs: {
-                    jid: authState.creds.me.id,
-                    stage: 'companion_hello',
-                    should_show_push_notification: 'true'
-                },
-                content: [{
-                        tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
-                        attrs: {},
-                        content: await generatePairingKey()
-                    },
-                    {
-                        tag: 'companion_server_auth_key_pub',
-                        attrs: {},
-                        content: authState.creds.noiseKey.public
-                    },
-                    {
-                        tag: 'companion_platform_id',
-                        attrs: {},
-                        content: Utils_1.getPlatformId(browser[1])
-                    },
-                    {
-                        tag: 'companion_platform_display',
-                        attrs: {},
-                        content: `${browser[1]} (${browser[0]})`
+            content: [
+                {
+                    tag: "link_code_companion_reg",
+                    attrs: {
+                        jid: authState.creds.me.id,
+                        stage: "companion_hello",
+                        should_show_push_notification: "true",
                     },
-                    {
-                        tag: 'link_code_pairing_nonce',
-                        attrs: {},
-                        content: '0'
-                    }
-                ]
-            }]
-        })
-
-        return authState.creds.pairingCode
-    }
-
+                    content: [
+                        {
+                            tag: "link_code_pairing_wrapped_companion_ephemeral_pub",
+                            attrs: {},
+                            content: await generatePairingKey(),
+                        },
+                        {
+                            tag: "companion_server_auth_key_pub",
+                            attrs: {},
+                            content: authState.creds.noiseKey.public,
+                        },
+                        {
+                            tag: "companion_platform_id",
+                            attrs: {},
+                            content: getPlatformId(browser[1]),
+                        },
+                        {
+                            tag: "companion_platform_display",
+                            attrs: {},
+                            content: `${browser[1]} (${browser[0]})`,
+                        },
+                        { tag: "link_code_pairing_nonce", attrs: {}, content: "0" },
+                    ],
+                },
+            ],
+        });
+        return authState.creds.pairingCode;
+    };
     async function generatePairingKey() {
-        const salt = crypto_1.randomBytes(32)
-        const randomIv = crypto_1.randomBytes(16)
-        const key = await Utils_1.derivePairingCodeKey(authState.creds.pairingCode, salt)
-        const ciphered = Utils_1.aesEncryptCTR(authState.creds.pairingEphemeralKeyPair.public, key, randomIv)
-
-        return Buffer.concat([salt, randomIv, ciphered])
-    }
-
-    const sendWAMBuffer = (wamBuffer) => {
-        return query({
-            tag: 'iq',
-            attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
-                id: generateMessageTag(),
-                xmlns: 'w:stats'
-            },
-            content: [{
-                tag: 'add',
-                attrs: {},
-                content: wamBuffer
-            }]
-        })
+        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]);
     }
-
-    ws.on('message', onMessageReceived)
-
-    ws.on('open', async () => {
+    const sendWAMBuffer = (wamBuffer) =>
+        query({
+            tag: "iq",
+            attrs: { to: S_WHATSAPP_NET, id: generateMessageTag(), xmlns: "w:stats" },
+            content: [
+                {
+                    tag: "add",
+                    attrs: { t: Math.round(Date.now() / 1e3) + "" },
+                    content: wamBuffer,
+                },
+            ],
+        });
+    ws.on("message", onMessageReceived);
+    ws.on("open", async () => {
         try {
-            await validateConnection()
+            await validateConnection();
         } catch (err) {
-            logger.error({
-                err
-            }, 'error in validating connection')
-            end(err)
-        }
-    })
-
-    ws.on('error', mapWebSocketError(end))
-
-    ws.on('close', () => end(new boom_1.Boom('Connection Terminated', {
-        statusCode: Types_1.DisconnectReason.connectionClosed
-    })))
-
-    ws.on('CB:xmlstreamend', () => end(new boom_1.Boom('Connection Terminated by Server', {
-        statusCode: Types_1.DisconnectReason.connectionClosed
-    })))
-
-    ws.on('CB:iq,type:set,pair-device', async (stanza) => {
+            logger.error({ err: err }, "error in validating connection");
+            end(err);
+        }
+    });
+    ws.on("error", mapWebSocketError(end));
+    ws.on("close", () =>
+        end(
+            new Boom("Connection Terminated", {
+                statusCode: DisconnectReason.connectionClosed,
+            })
+        )
+    );
+    ws.on("CB:xmlstreamend", () =>
+        end(
+            new Boom("Connection Terminated by Server", {
+                statusCode: DisconnectReason.connectionClosed,
+            })
+        )
+    );
+    ws.on("CB:iq,type:set,pair-device", async (stanza) => {
         const iq = {
-            tag: 'iq',
-            attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
-                type: 'result',
-                id: stanza.attrs.id,
-            }
-        }
-
-        await sendNode(iq)
-
-        const pairDeviceNode = WABinary_1.getBinaryNodeChild(stanza, 'pair-device')
-        const refNodes = WABinary_1.getBinaryNodeChildren(pairDeviceNode, 'ref')
-        const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString('base64')
-        const identityKeyB64 = Buffer.from(creds.signedIdentityKey.public).toString('base64')
-        const advB64 = creds.advSecretKey
-
-        let qrMs = qrTimeout || 60000 // time to let a QR live
-
+            tag: "iq",
+            attrs: { to: S_WHATSAPP_NET, type: "result", id: stanza.attrs.id },
+        };
+        await sendNode(iq);
+        const pairDeviceNode = getBinaryNodeChild(stanza, "pair-device");
+        const refNodes = getBinaryNodeChildren(pairDeviceNode, "ref");
+        const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString("base64");
+        const identityKeyB64 = Buffer.from(creds.signedIdentityKey.public).toString("base64");
+        const advB64 = creds.advSecretKey;
+        let qrMs = qrTimeout || 6e4;
         const genPairQR = () => {
             if (!ws.isOpen) {
-                return
+                return;
             }
-
-            const refNode = refNodes.shift()
-
+            const refNode = refNodes.shift();
             if (!refNode) {
-                end(new boom_1.Boom('QR refs attempts ended', {
-                    statusCode: Types_1.DisconnectReason.timedOut
-                }))
-                return
+                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(',')
-
-            ev.emit('connection.update', {
-                qr
-            })
-            qrTimer = setTimeout(genPairQR, qrMs)
-            qrMs = qrTimeout || 20000
-        }
-
-        genPairQR()
-    })
-
-    ws.on('CB:iq,,pair-success', async (stanza) => {
-        logger.debug('pair success recv')
+            const ref = refNode.content.toString("utf-8");
+            const qr = [ref, noiseKeyB64, identityKeyB64, advB64].join(",");
+            ev.emit("connection.update", { qr: qr });
+            qrTimer = setTimeout(genPairQR, qrMs);
+            qrMs = qrTimeout || 2e4;
+        };
+        genPairQR();
+    });
+    ws.on("CB:iq,,pair-success", async (stanza) => {
+        logger.debug("pair success recv");
         try {
-            const {
-                reply,
-                creds: updatedCreds
-            } = Utils_1.configureSuccessfulPairing(stanza, creds)
-            logger.info({
-                me: updatedCreds.me,
-                platform: updatedCreds.platform
-            }, 'pairing configured successfully, expect to restart the connection...')
-
-            ev.emit('creds.update', updatedCreds)
-            ev.emit('connection.update', {
-                isNewLogin: true,
-                qr: undefined
-            })
-
-            await sendNode(reply)
+            const { reply: reply, creds: updatedCreds } = configureSuccessfulPairing(stanza, creds);
+            logger.info(
+                { me: updatedCreds.me, platform: updatedCreds.platform },
+                "pairing configured successfully, expect to restart the connection..."
+            );
+            ev.emit("creds.update", updatedCreds);
+            ev.emit("connection.update", { isNewLogin: true, qr: undefined });
+            await sendNode(reply);
         } catch (error) {
-            logger.info({
-                trace: error.stack
-            }, 'error in pairing')
-            end(error)
+            logger.info({ trace: error.stack }, "error in pairing");
+            end(error);
         }
-    })
-
-    ws.on('CB:success', async (node) => {
+    });
+    ws.on("CB:success", async (node) => {
         try {
-            await uploadPreKeysToServerIfRequired()
-            // Jalankan ulang pengecekan prekey tiap 6 jam selama koneksi hidup, bukan
-            // cuma sekali pas connect. uploadPreKeysToServerIfRequired() sendiri sudah
-            // pintar (cuma benar-benar upload kalau count di server rendah/ada yang
-            // hilang), jadi interval ini murah dan aman dijalankan berkala.
-            clearInterval(preKeyCheckInterval)
-            preKeyCheckInterval = setInterval(() => {
-                uploadPreKeysToServerIfRequired().catch((err) => {
-                    logger.warn({ err }, 'periodic pre-key check failed')
-                })
-            }, 6 * 60 * 60 * 1000)
-            await sendPassiveIq('active')
+            await uploadPreKeysToServerIfRequired();
+            await sendPassiveIq("active");
+            try {
+                await digestKeyBundle();
+            } catch (e) {
+                logger.warn({ e: e }, "failed to run digest after login");
+            }
         } catch (err) {
-            logger.warn({
-                err
-            }, 'failed to send initial passive iq');
+            logger.warn({ err: err }, "failed to send initial passive iq");
         }
-        logger.info('opened connection to WA')
+        logger.info("opened connection to WA");
         clearTimeout(qrTimer);
-        ev.emit('creds.update', {
-            me: {
-                ...authState.creds.me,
-                lid: node.attrs.lid
-            }
-        })
-        ev.emit('connection.update', {
-            connection: 'open'
-        })
+        ev.emit("creds.update", {
+            me: { ...authState.creds.me, lid: node.attrs.lid },
+        });
+        ev.emit("connection.update", { connection: "open" });
         if (node.attrs.lid && authState.creds.me?.id) {
-            const myLID = node.attrs.lid
+            const myLID = node.attrs.lid;
             process.nextTick(async () => {
                 try {
-                    const myPN = authState.creds.me.id
-
-                    await signalRepository.lidMapping.storeLIDPNMappings([{
-                        lid: myLID,
-                        pn: myPN
-                    }])
-
-                    logger.info({
-                        myPN,
-                        myLID
-                    }, 'Own LID session created successfully')
+                    const myPN = authState.creds.me.id;
+                    await signalRepository.lidMapping.storeLIDPNMappings([
+                        { lid: myLID, pn: myPN },
+                    ]);
+                    const { user: user, device: device } = jidDecode(myPN);
+                    await authState.keys.set({
+                        "device-list": { [user]: [device?.toString() || "0"] },
+                    });
+                    await signalRepository.migrateSession(myPN, myLID);
+                    logger.info(
+                        { myPN: myPN, myLID: myLID },
+                        "Own LID session created successfully"
+                    );
                 } catch (error) {
-                    logger.error({
-                        error,
-                        lid: myLID
-                    }, 'Failed to create own LID session')
+                    logger.error({ error: error, lid: myLID }, "Failed to create own LID session");
                 }
+            });
+        }
+    });
+    ws.on("CB:stream:error", (node) => {
+        const [reasonNode] = getAllBinaryNodeChildren(node);
+        logger.error({ reasonNode: reasonNode, fullErrorNode: node }, "stream errored out");
+        const { reason: reason, statusCode: statusCode } = getErrorCodeFromStreamError(node);
+        end(
+            new Boom(`Stream Errored (${reason})`, {
+                statusCode: statusCode,
+                data: reasonNode || node,
             })
-        }
-    })
-
-    ws.on('CB:stream:error', (node) => {
-        logger.error({
-            node
-        }, 'stream errored out')
-        const {
-            reason,
-            statusCode
-        } = Utils_1.getErrorCodeFromStreamError(node)
-
-        end(new boom_1.Boom(`Stream Errored (${reason})`, {
-            statusCode,
-            data: node
-        }))
-    })
-
-    ws.on('CB:failure', (node) => {
-        const reason = +(node.attrs.reason || 500)
-
-        end(new boom_1.Boom('Connection Failure', {
-            statusCode: reason,
-            data: node.attrs
-        }))
-    })
-
-    ws.on('CB:ib,,downgrade_webclient', () => {
-        end(new boom_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))
-
+        );
+    });
+    ws.on("CB:failure", (node) => {
+        const reason = +(node.attrs.reason || 500);
+        end(new 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,
+            })
+        );
+    });
+    ws.on("CB:ib,,offline_preview", (node) => {
+        logger.info("offline preview received", JSON.stringify(node));
         sendNode({
-            tag: 'ib',
+            tag: "ib",
             attrs: {},
-            content: [{
-                tag: 'offline_batch',
-                attrs: {
-                    count: '100'
-                }
-            }]
-        })
-    })
-
-    ws.on('CB:ib,,edge_routing', (node) => {
-        const edgeRoutingNode = WABinary_1.getBinaryNodeChild(node, 'edge_routing')
-        const routingInfo = WABinary_1.getBinaryNodeChild(edgeRoutingNode, 'routing_info')
-
+            content: [{ tag: "offline_batch", attrs: { count: "100" } }],
+        });
+    });
+    ws.on("CB:ib,,edge_routing", (node) => {
+        const edgeRoutingNode = getBinaryNodeChild(node, "edge_routing");
+        const routingInfo = getBinaryNodeChild(edgeRoutingNode, "routing_info");
         if (routingInfo?.content) {
-            authState.creds.routingInfo = Buffer.from(routingInfo?.content)
-            ev.emit('creds.update', authState.creds)
+            authState.creds.routingInfo = Buffer.from(routingInfo?.content);
+            ev.emit("creds.update", authState.creds);
         }
-    })
-
-    let didStartBuffer = false
-
+    });
+    let didStartBuffer = false;
     process.nextTick(() => {
         if (creds.me?.id) {
-            ev.buffer()
-            didStartBuffer = true
+            ev.buffer();
+            didStartBuffer = true;
         }
-
-        ev.emit('connection.update', {
-            connection: 'connecting',
+        ev.emit("connection.update", {
+            connection: "connecting",
             receivedPendingNotifications: false,
-            qr: undefined
-        })
-    })
-
-    ws.on('CB:ib,,offline', (node) => {
-        const child = WABinary_1.getBinaryNodeChild(node, 'offline')
-        const offlineNotifs = +(child?.attrs.count || 0)
-
-        logger.info(`handled ${offlineNotifs} offline messages/notifications`)
-
+            qr: undefined,
+        });
+    });
+    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) {
-            ev.flush()
-            logger.trace('flushed events for initial buffer')
+            ev.flush();
+            logger.trace("flushed events for initial buffer");
         }
-
-        ev.emit('connection.update', {
-            receivedPendingNotifications: true
-        })
-    })
-
-    ev.on('creds.update', update => {
-        const name = update.me?.name
+        ev.emit("connection.update", { receivedPendingNotifications: true });
+    });
+    ev.on("creds.update", (update) => {
+        const name = update.me?.name;
         if (creds.me?.name !== name) {
-            logger.debug({
-                name
-            }, 'updated pushName')
-
-            sendNode({
-                tag: 'presence',
-                attrs: {
-                    name
-                }
-            }).catch(err => {
-                logger.warn({
-                    trace: err.stack
-                }, 'error in sending presence update on name change')
-            })
-        }
-        Object.assign(creds, update)
-    })
-
+            logger.debug({ name: name }, "updated pushName");
+            sendNode({ tag: "presence", attrs: { name: name } }).catch((err) => {
+                logger.warn(
+                    { trace: err.stack },
+                    "error in sending presence update on name change"
+                );
+            });
+        }
+        Object.assign(creds, update);
+    });
     if (printQRInTerminal) {
-        Utils_1.printQRIfNecessaryListener(ev, logger)
+        printQRIfNecessaryListener(ev, logger);
     }
-
     return {
-        type: 'meta',
-        ws,
-        ev,
-        authState: {
-            creds,
-            keys
-        },
-        signalRepository,
+        type: "md",
+        ws: ws,
+        ev: ev,
+        authState: { creds: creds, keys: keys },
+        signalRepository: signalRepository,
         get user() {
-            return authState.creds.me
+            return authState.creds.me;
         },
-        generateMessageTag,
-        query,
-        waitForMessage,
-        waitForSocketOpen,
-        sendRawMessage,
-        sendNode,
-        logout,
-        end,
-        onUnexpectedError,
-        uploadPreKeys,
-        uploadPreKeysToServerIfRequired,
-        requestPairingCode,
-        waitForConnectionUpdate: Utils_1.bindWaitForConnectionUpdate(ev),
-        sendWAMBuffer,
-        executeUSyncQuery,
-        onWhatsApp,
-        logger
-    }
-}
-
+        generateMessageTag: generateMessageTag,
+        query: query,
+        waitForMessage: waitForMessage,
+        waitForSocketOpen: waitForSocketOpen,
+        sendRawMessage: sendRawMessage,
+        sendNode: sendNode,
+        logout: logout,
+        end: end,
+        onUnexpectedError: onUnexpectedError,
+        uploadPreKeys: uploadPreKeys,
+        uploadPreKeysToServerIfRequired: uploadPreKeysToServerIfRequired,
+        digestKeyBundle: digestKeyBundle,
+        rotateSignedPreKey: rotateSignedPreKey,
+        requestPairingCode: requestPairingCode,
+        wamBuffer: publicWAMBuffer,
+        waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
+        sendWAMBuffer: sendWAMBuffer,
+        executeUSyncQuery: executeUSyncQuery,
+        onWhatsApp: onWhatsApp,
+    };
+};
 function mapWebSocketError(handler) {
     return (error) => {
-        handler(new boom_1.Boom(`WebSocket Error (${error?.message})`, {
-            statusCode: Utils_1.getCodeFromWSError(error),
-            data: error
-        }))
-    }
+        handler(
+            new Boom(`WebSocket Error (${error?.message})`, {
+                statusCode: getCodeFromWSError(error),
+                data: error,
+            })
+        );
+    };
 }
-
-module.exports = {
-    makeSocket
-}
+module.exports = { makeSocket: makeSocket };