gifted-baileys 1.5.0 → 1.5.5

package/src/Socket/registration.ts

@@ -0,0 +1,250 @@
+/* eslint-disable camelcase */
+import axios, { AxiosRequestConfig } from 'axios'
+import { MOBILE_REGISTRATION_ENDPOINT, MOBILE_TOKEN, MOBILE_USERAGENT, REGISTRATION_PUBLIC_KEY } from '../Defaults'
+import { KeyPair, SignedKeyPair, SocketConfig } from '../Types'
+import { aesEncryptGCM, Curve, md5 } from '../Utils/crypto'
+import { jidEncode } from '../WABinary'
+import { makeBusinessSocket } from './business'
+
+function urlencode(str: string) {
+	return str.replace(/-/g, '%2d').replace(/_/g, '%5f').replace(/~/g, '%7e')
+}
+
+const validRegistrationOptions = (config: RegistrationOptions) => config?.phoneNumberCountryCode &&
+	config.phoneNumberNationalNumber &&
+	config.phoneNumberMobileCountryCode
+
+export const makeRegistrationSocket = (config: SocketConfig) => {
+	const sock = makeBusinessSocket(config)
+
+	const register = async(code: string) => {
+		if(!validRegistrationOptions(config.auth.creds.registration)) {
+			throw new Error('please specify the registration options')
+		}
+
+		const result = await mobileRegister({ ...sock.authState.creds, ...sock.authState.creds.registration as RegistrationOptions, code }, config.options)
+
+		sock.authState.creds.me = {
+			id: jidEncode(result.login!, 's.whatsapp.net'),
+			name: '~'
+		}
+
+		sock.authState.creds.registered = true
+		sock.ev.emit('creds.update', sock.authState.creds)
+
+		return result
+	}
+
+	const requestRegistrationCode = async(registrationOptions?: RegistrationOptions) => {
+		registrationOptions = registrationOptions || config.auth.creds.registration
+		if(!validRegistrationOptions(registrationOptions)) {
+			throw new Error('Invalid registration options')
+		}
+
+		sock.authState.creds.registration = registrationOptions
+
+		sock.ev.emit('creds.update', sock.authState.creds)
+
+		return mobileRegisterCode({ ...config.auth.creds, ...registrationOptions }, config.options)
+	}
+
+	return {
+		...sock,
+		register,
+		requestRegistrationCode,
+	}
+}
+
+// Backup_token: Base64.getEncoder().encodeToString(Arrays.copyOfRange(Base64.getDecoder().decode(UUID.randomUUID().toString().replace('-','')),0,15))
+
+export interface RegistrationData {
+	registrationId: number
+	signedPreKey: SignedKeyPair
+	noiseKey: KeyPair
+	signedIdentityKey: KeyPair
+	identityId: Buffer
+	phoneId: string
+	deviceId: string
+	backupToken: Buffer
+}
+
+export interface RegistrationOptions {
+	/** your phone number */
+	phoneNumber?: string
+	/** the country code of your phone number */
+	phoneNumberCountryCode: string
+	/** your phone number without country code */
+	phoneNumberNationalNumber: string
+	/** the country code of your mobile network
+	 * @see {@link https://de.wikipedia.org/wiki/Mobile_Country_Code}
+	 */
+	phoneNumberMobileCountryCode: string
+	/** the network code of your mobile network
+	 * @see {@link https://de.wikipedia.org/wiki/Mobile_Network_Code}
+	 */
+	phoneNumberMobileNetworkCode: string
+	/**
+	 * How to send the one time code
+	 */
+	method?: 'sms' | 'voice' | 'captcha'
+	/**
+	 * The captcha code if it was requested
+	 */
+	captcha?: string
+}
+
+export type RegistrationParams = RegistrationData & RegistrationOptions
+
+function convertBufferToUrlHex(buffer: Buffer) {
+	var id = ''
+
+	buffer.forEach((x) => {
+		// encode random identity_id buffer as percentage url encoding
+		id += `%${x.toString(16).padStart(2, '0').toLowerCase()}`
+	})
+
+	return id
+}
+
+export function registrationParams(params: RegistrationParams) {
+	const e_regid = Buffer.alloc(4)
+	e_regid.writeInt32BE(params.registrationId)
+
+	const e_skey_id = Buffer.alloc(3)
+	e_skey_id.writeInt16BE(params.signedPreKey.keyId)
+
+	params.phoneNumberCountryCode = params.phoneNumberCountryCode.replace('+', '').trim()
+	params.phoneNumberNationalNumber = params.phoneNumberNationalNumber.replace(/[/-\s)(]/g, '').trim()
+
+	return {
+		cc: params.phoneNumberCountryCode,
+		in: params.phoneNumberNationalNumber,
+		Rc: '0',
+		lg: 'en',
+		lc: 'GB',
+		mistyped: '6',
+		authkey: Buffer.from(params.noiseKey.public).toString('base64url'),
+		e_regid: e_regid.toString('base64url'),
+		e_keytype: 'BQ',
+		e_ident: Buffer.from(params.signedIdentityKey.public).toString('base64url'),
+		// e_skey_id: e_skey_id.toString('base64url'),
+		e_skey_id: 'AAAA',
+		e_skey_val: Buffer.from(params.signedPreKey.keyPair.public).toString('base64url'),
+		e_skey_sig: Buffer.from(params.signedPreKey.signature).toString('base64url'),
+		fdid: params.phoneId,
+		network_ratio_type: '1',
+		expid: params.deviceId,
+		simnum: '1',
+		hasinrc: '1',
+		pid: Math.floor(Math.random() * 1000).toString(),
+		id: convertBufferToUrlHex(params.identityId),
+		backup_token: convertBufferToUrlHex(params.backupToken),
+		token: md5(Buffer.concat([MOBILE_TOKEN, Buffer.from(params.phoneNumberNationalNumber)])).toString('hex'),
+		fraud_checkpoint_code: params.captcha,
+	}
+}
+
+/**
+ * Requests a registration code for the given phone number.
+ */
+export function mobileRegisterCode(params: RegistrationParams, fetchOptions?: AxiosRequestConfig) {
+	return mobileRegisterFetch('/code', {
+		params: {
+			...registrationParams(params),
+			mcc: `${params.phoneNumberMobileCountryCode}`.padStart(3, '0'),
+			mnc: `${params.phoneNumberMobileNetworkCode || '001'}`.padStart(3, '0'),
+			sim_mcc: '000',
+			sim_mnc: '000',
+			method: params?.method || 'sms',
+			reason: '',
+			hasav: '1'
+		},
+		...fetchOptions,
+	})
+}
+
+export function mobileRegisterExists(params: RegistrationParams, fetchOptions?: AxiosRequestConfig) {
+	return mobileRegisterFetch('/exist', {
+		params: registrationParams(params),
+		...fetchOptions
+	})
+}
+
+/**
+ * Registers the phone number on whatsapp with the received OTP code.
+ */
+export async function mobileRegister(params: RegistrationParams & { code: string }, fetchOptions?: AxiosRequestConfig) {
+	//const result = await mobileRegisterFetch(`/reg_onboard_abprop?cc=${params.phoneNumberCountryCode}&in=${params.phoneNumberNationalNumber}&rc=0`)
+
+	return mobileRegisterFetch('/register', {
+		params: { ...registrationParams(params), code: params.code.replace('-', '') },
+		...fetchOptions,
+	})
+}
+
+/**
+ * Encrypts the given string as AEAD aes-256-gcm with the public whatsapp key and a random keypair.
+ */
+export function mobileRegisterEncrypt(data: string) {
+	const keypair = Curve.generateKeyPair()
+	const key = Curve.sharedKey(keypair.private, REGISTRATION_PUBLIC_KEY)
+
+	const buffer = aesEncryptGCM(Buffer.from(data), new Uint8Array(key), Buffer.alloc(12), Buffer.alloc(0))
+
+	return Buffer.concat([Buffer.from(keypair.public), buffer]).toString('base64url')
+}
+
+export async function mobileRegisterFetch(path: string, opts: AxiosRequestConfig = {}) {
+	let url = `${MOBILE_REGISTRATION_ENDPOINT}${path}`
+
+	if(opts.params) {
+		const parameter = [] as string[]
+
+		for(const param in opts.params) {
+			if(opts.params[param] !== null && opts.params[param] !== undefined) {
+				parameter.push(param + '=' + urlencode(opts.params[param]))
+			}
+		}
+
+		url += `?${parameter.join('&')}`
+		delete opts.params
+	}
+
+	if(!opts.headers) {
+		opts.headers = {}
+	}
+
+	opts.headers['User-Agent'] = MOBILE_USERAGENT
+
+	const response = await axios(url, opts)
+
+	var json = response.data
+
+	if(response.status > 300 || json.reason) {
+		throw json
+	}
+
+	if(json.status && !['ok', 'sent'].includes(json.status)) {
+		throw json
+	}
+
+	return json as ExistsResponse
+}
+
+
+export interface ExistsResponse {
+	status: 'fail' | 'sent'
+	voice_length?: number
+	voice_wait?: number
+	sms_length?: number
+	sms_wait?: number
+	reason?: 'incorrect' | 'missing_param' | 'code_checkpoint'
+	login?: string
+	flash_type?: number
+	ab_hash?: string
+	ab_key?: string
+	exp_cfg?: string
+	lid?: string
+	image_blob?: string
+	audio_blob?: string
+}

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

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSocket = void 0;
 const boom_1 = require("@hapi/boom");
@@ -18,12 +27,16 @@ const Client_1 = require("./Client");
  * - query phone connection
  */
 const makeSocket = (config) => {
+    var _a, _b;
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository, } = config;
     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 (!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 = config.socket ? config.socket : config.mobile ? new Client_1.MobileSocketClient(url, config) : new Client_1.WebSocketClient(url, config);
     ws.connect();
     const ev = (0, Utils_1.makeEventBuffer)(logger);
@@ -34,7 +47,8 @@ const makeSocket = (config) => {
         keyPair: ephemeralKeyPair,
         NOISE_HEADER: config.mobile ? Defaults_1.MOBILE_NOISE_HEADER : Defaults_1.NOISE_WA_HEADER,
         mobile: config.mobile,
-        logger
+        logger,
+        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
@@ -49,25 +63,25 @@ const makeSocket = (config) => {
     const generateMessageTag = () => `${uqTagId}${epoch++}`;
     const sendPromise = (0, util_1.promisify)(ws.send);
     /** send a raw buffer */
-    const sendRawMessage = async (data) => {
+    const sendRawMessage = (data) => __awaiter(void 0, void 0, void 0, function* () {
         if (!ws.isOpen) {
             throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed });
         }
         const bytes = noise.encodeFrame(data);
-        await (0, Utils_1.promiseTimeout)(connectTimeoutMs, async (resolve, reject) => {
+        yield (0, Utils_1.promiseTimeout)(connectTimeoutMs, (resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
             try {
-                await sendPromise.call(ws, bytes);
+                yield sendPromise.call(ws, bytes);
                 resolve();
             }
             catch (error) {
                 reject(error);
             }
-        });
-    };
+        }));
+    });
     /** send a binary node */
     const sendNode = (frame) => {
         if (logger.level === 'trace') {
-            logger.trace((0, WABinary_1.binaryNodeToString)(frame), 'xml send');
+            logger.trace({ xml: (0, WABinary_1.binaryNodeToString)(frame), msg: 'xml send' });
         }
         const buff = (0, WABinary_1.encodeBinaryNode)(frame);
         return sendRawMessage(buff);
@@ -77,7 +91,7 @@ const makeSocket = (config) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
     };
     /** await the next incoming message */
-    const awaitNextMessage = async (sendMsg) => {
+    const awaitNextMessage = (sendMsg) => __awaiter(void 0, void 0, void 0, function* () {
         if (!ws.isOpen) {
             throw new boom_1.Boom('Connection Closed', {
                 statusCode: Types_1.DisconnectReason.connectionClosed
@@ -101,17 +115,17 @@ const makeSocket = (config) => {
             sendRawMessage(sendMsg).catch(onClose);
         }
         return result;
-    };
+    });
     /**
      * Wait for a message with a certain tag to be received
      * @param msgId the message tag to await
      * @param timeoutMs timeout after which the promise will reject
      */
-    const waitForMessage = async (msgId, timeoutMs = defaultQueryTimeoutMs) => {
+    const waitForMessage = (msgId_1, ...args_1) => __awaiter(void 0, [msgId_1, ...args_1], void 0, function* (msgId, timeoutMs = defaultQueryTimeoutMs) {
         let onRecv;
         let onErr;
         try {
-            return await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
+            return yield (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
                 onRecv = resolve;
                 onErr = err => {
                     reject(err || new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed }));
@@ -126,30 +140,30 @@ const makeSocket = (config) => {
             ws.off('close', onErr); // if the socket closes, you'll never receive the message
             ws.off('error', onErr);
         }
-    };
+    });
     /** send a query, and wait for its response. auto-generates message ID if not provided */
-    const query = async (node, timeoutMs) => {
+    const query = (node, timeoutMs) => __awaiter(void 0, void 0, void 0, function* () {
         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;
+        yield sendNode(node);
+        const result = yield wait;
         if ('tag' in result) {
             (0, WABinary_1.assertNodeErrorFree)(result);
         }
         return result;
-    };
+    });
     /** connection handshake */
-    const validateConnection = async () => {
+    const validateConnection = () => __awaiter(void 0, void 0, void 0, function* () {
         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 result = yield awaitNextMessage(init);
         const handshake = WAProto_1.proto.HandshakeMessage.decode(result);
         logger.trace({ handshake }, 'handshake recv from WA');
         const keyEnc = noise.processHandshake(handshake, creds.noiseKey);
@@ -166,7 +180,7 @@ const makeSocket = (config) => {
             logger.info({ node }, 'logging in...');
         }
         const payloadEnc = noise.encrypt(WAProto_1.proto.ClientPayload.encode(node).finish());
-        await sendRawMessage(WAProto_1.proto.HandshakeMessage.encode({
+        yield sendRawMessage(WAProto_1.proto.HandshakeMessage.encode({
             clientFinish: {
                 static: keyEnc,
                 payload: payloadEnc,
@@ -174,9 +188,9 @@ const makeSocket = (config) => {
         }).finish());
         noise.finishInit();
         startKeepAliveRequest();
-    };
-    const getAvailablePreKeysOnServer = async () => {
-        const result = await query({
+    });
+    const getAvailablePreKeysOnServer = () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield query({
             tag: 'iq',
             attrs: {
                 id: generateMessageTag(),
@@ -190,25 +204,25 @@ const makeSocket = (config) => {
         });
         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 = Defaults_1.INITIAL_PREKEY_COUNT) => {
-        await keys.transaction(async () => {
+    const uploadPreKeys = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (count = Defaults_1.INITIAL_PREKEY_COUNT) {
+        yield keys.transaction(() => __awaiter(void 0, void 0, void 0, function* () {
             logger.info({ count }, 'uploading pre-keys');
-            const { update, node } = await (0, Utils_1.getNextPreKeysNode)({ creds, keys }, count);
-            await query(node);
+            const { update, node } = yield (0, Utils_1.getNextPreKeysNode)({ creds, keys }, count);
+            yield query(node);
             ev.emit('creds.update', update);
             logger.info({ count }, 'uploaded pre-keys');
-        });
-    };
-    const uploadPreKeysToServerIfRequired = async () => {
-        const preKeyCount = await getAvailablePreKeysOnServer();
+        }));
+    });
+    const uploadPreKeysToServerIfRequired = () => __awaiter(void 0, void 0, void 0, function* () {
+        const preKeyCount = yield getAvailablePreKeysOnServer();
         logger.info(`${preKeyCount} pre-keys found on server`);
         if (preKeyCount <= Defaults_1.MIN_PREKEY_COUNT) {
-            await uploadPreKeys();
+            yield uploadPreKeys();
         }
-    };
-    const onMessageRecieved = (data) => {
+    });
+    const onMessageReceived = (data) => {
         noise.decodeFrame(data, frame => {
             var _a;
             // reset ping timeout
@@ -219,7 +233,7 @@ const makeSocket = (config) => {
             if (!(frame instanceof Uint8Array)) {
                 const msgId = frame.attrs.id;
                 if (logger.level === 'trace') {
-                    logger.trace((0, WABinary_1.binaryNodeToString)(frame), '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(`${Defaults_1.DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered;
@@ -268,7 +282,7 @@ const makeSocket = (config) => {
         });
         ev.removeAllListeners('connection.update');
     };
-    const waitForSocketOpen = async () => {
+    const waitForSocketOpen = () => __awaiter(void 0, void 0, void 0, function* () {
         if (ws.isOpen) {
             return;
         }
@@ -277,7 +291,7 @@ const makeSocket = (config) => {
         }
         let onOpen;
         let onClose;
-        await new Promise((resolve, reject) => {
+        yield new Promise((resolve, reject) => {
             onOpen = () => resolve(undefined);
             onClose = mapWebSocketError(reject);
             ws.on('open', onOpen);
@@ -289,7 +303,7 @@ const makeSocket = (config) => {
             ws.off('close', onClose);
             ws.off('error', onClose);
         });
-    };
+    });
     const startKeepAliveRequest = () => (keepAliveReq = setInterval(() => {
         if (!lastDateRecv) {
             lastDateRecv = new Date();
@@ -335,11 +349,11 @@ const makeSocket = (config) => {
         ]
     }));
     /** logout & invalidate connection */
-    const logout = async (msg) => {
+    const logout = (msg) => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
         const jid = (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id;
         if (jid) {
-            await sendNode({
+            yield sendNode({
                 tag: 'iq',
                 attrs: {
                     to: WABinary_1.S_WHATSAPP_NET,
@@ -359,15 +373,15 @@ const makeSocket = (config) => {
             });
         }
         end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }));
-    };
-    const requestPairingCode = async (phoneNumber) => {
+    });
+    const requestPairingCode = (phoneNumber) => __awaiter(void 0, void 0, void 0, function* () {
         authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
         authState.creds.me = {
             id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
             name: '~'
         };
         ev.emit('creds.update', authState.creds);
-        await sendNode({
+        yield sendNode({
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
@@ -388,7 +402,7 @@ const makeSocket = (config) => {
                         {
                             tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
                             attrs: {},
-                            content: await generatePairingKey()
+                            content: yield generatePairingKey()
                         },
                         {
                             tag: 'companion_server_auth_key_pub',
@@ -415,30 +429,49 @@ const makeSocket = (config) => {
             ]
         });
         return authState.creds.pairingCode;
-    };
-    async function generatePairingKey() {
-        const salt = (0, crypto_1.randomBytes)(32);
-        const randomIv = (0, crypto_1.randomBytes)(16);
-        const key = (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]);
+    });
+    function generatePairingKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const salt = (0, crypto_1.randomBytes)(32);
+            const randomIv = (0, crypto_1.randomBytes)(16);
+            const key = (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]);
+        });
     }
-    ws.on('message', onMessageRecieved);
-    ws.on('open', async () => {
+    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
+                }
+            ]
+        });
+    };
+    ws.on('message', onMessageReceived);
+    ws.on('open', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            await validateConnection();
+            yield 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 })));
     // the server terminated the connection
     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) => {
+    ws.on('CB:iq,type:set,pair-device', (stanza) => __awaiter(void 0, void 0, void 0, function* () {
         const iq = {
             tag: 'iq',
             attrs: {
@@ -447,7 +480,7 @@ const makeSocket = (config) => {
                 id: stanza.attrs.id,
             }
         };
-        await sendNode(iq);
+        yield sendNode(iq);
         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');
@@ -470,32 +503,32 @@ const makeSocket = (config) => {
             qrMs = qrTimeout || 20000; // shorter subsequent qrs
         };
         genPairQR();
-    });
+    }));
     // device paired for the first time
     // if device pairs successfully, the server asks to restart the connection
-    ws.on('CB:iq,,pair-success', async (stanza) => {
+    ws.on('CB:iq,,pair-success', (stanza) => __awaiter(void 0, void 0, void 0, function* () {
         logger.debug('pair success recv');
         try {
             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 });
-            await sendNode(reply);
+            yield sendNode(reply);
         }
         catch (error) {
             logger.info({ trace: error.stack }, 'error in pairing');
             end(error);
         }
-    });
+    }));
     // login complete
-    ws.on('CB:success', async (node) => {
-        await uploadPreKeysToServerIfRequired();
-        await sendPassiveIq('active');
+    ws.on('CB:success', (node) => __awaiter(void 0, void 0, void 0, function* () {
+        yield uploadPreKeysToServerIfRequired();
+        yield 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('creds.update', { me: Object.assign(Object.assign({}, authState.creds.me), { lid: node.attrs.lid }) });
         ev.emit('connection.update', { connection: 'open' });
-    });
+    }));
     ws.on('CB:stream:error', (node) => {
         logger.error({ node }, 'stream errored out');
         const { reason, statusCode } = (0, Utils_1.getErrorCodeFromStreamError)(node);
@@ -509,6 +542,13 @@ const makeSocket = (config) => {
     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,,edge_routing', (node) => {
+        const edgeRoutingNode = (0, WABinary_1.getBinaryNodeChild)(node, 'edge_routing');
+        const routingInfo = (0, WABinary_1.getBinaryNodeChild)(edgeRoutingNode, 'routing_info');
+        if (routingInfo === null || routingInfo === void 0 ? void 0 : routingInfo.content) {
+            authState.creds.routingInfo = Buffer.from(routingInfo === null || routingInfo === void 0 ? void 0 : routingInfo.content);
+        }
+    });
     let didStartBuffer = false;
     process.nextTick(() => {
         var _a;
@@ -574,6 +614,7 @@ const makeSocket = (config) => {
         requestPairingCode,
         /** Waits for the connection to WA to reach a state */
         waitForConnectionUpdate: (0, Utils_1.bindWaitForConnectionUpdate)(ev),
+        sendWAMBuffer,
     };
 };
 exports.makeSocket = makeSocket;