@baileys-md/baileys 11.0.3 → 11.1.0

package/lib/Utils/signal.js

@@ -1,105 +1,96 @@
-import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
-import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
-import { Curve, generateSignalPubKey } from './crypto.js';
-import { encodeBigEndian } from './generics.js';
-function chunk(array, size) {
-    const chunks = [];
-    for (let i = 0; i < array.length; i += size) {
-        chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
-}
-export const createSignalIdentity = (wid, accountSignatureKey) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids = exports.parseAndInjectE2ESessions = exports.xmppPreKey = exports.xmppSignedPreKey = exports.generateOrGetPreKeys = exports.getPreKeys = exports.createSignalIdentity = void 0;
+const Defaults_1 = require("../Defaults");
+const WABinary_1 = require("../WABinary");
+const crypto_1 = require("./crypto");
+const generics_1 = require("./generics");
+const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
         identifier: { name: wid, deviceId: 0 },
-        identifierKey: generateSignalPubKey(accountSignatureKey)
+        identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
     };
 };
-export const getPreKeys = async ({ get }, min, limit) => {
+exports.createSignalIdentity = createSignalIdentity;
+const getPreKeys = async ({ get }, min, limit) => {
     const idList = [];
     for (let id = min; id < limit; id++) {
         idList.push(id.toString());
     }
     return get('pre-key', idList);
 };
-export const generateOrGetPreKeys = (creds, range) => {
+exports.getPreKeys = getPreKeys;
+const generateOrGetPreKeys = (creds, range) => {
     const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
     const remaining = range - avaliable;
     const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
     const newPreKeys = {};
     if (remaining > 0) {
         for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = Curve.generateKeyPair();
+            newPreKeys[i] = crypto_1.Curve.generateKeyPair();
         }
     }
     return {
         newPreKeys,
         lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range],
     };
 };
-export const xmppSignedPreKey = (key) => ({
+exports.generateOrGetPreKeys = generateOrGetPreKeys;
+const xmppSignedPreKey = (key) => ({
     tag: 'skey',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
         { tag: 'value', attrs: {}, content: key.keyPair.public },
         { tag: 'signature', attrs: {}, content: key.signature }
     ]
 });
-export const xmppPreKey = (pair, id) => ({
+exports.xmppSignedPreKey = xmppSignedPreKey;
+const xmppPreKey = (pair, id) => ({
     tag: 'key',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
         { tag: 'value', attrs: {}, content: pair.public }
     ]
 });
-export const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = (key) => key
-        ? {
-            keyId: getBinaryNodeChildUInt(key, 'id', 3),
-            publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
-            signature: getBinaryNodeChildBuffer(key, 'signature')
-        }
-        : undefined;
-    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user');
+exports.xmppPreKey = xmppPreKey;
+const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => (key ? ({
+        keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
+        publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
+        signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature'),
+    }) : undefined);
+    const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user');
     for (const node of nodes) {
-        assertNodeErrorFree(node);
-    }
-    // Most of the work in repository.injectE2ESession is CPU intensive, not IO
-    // So Promise.all doesn't really help here,
-    // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
-    // This way we chunk it in smaller parts and between those parts we can yield to the event loop
-    // It's rare case when you need to E2E sessions for so many users, but it's possible
-    const chunkSize = 100;
-    const chunks = chunk(nodes, chunkSize);
-    for (const nodesChunk of chunks) {
-        await Promise.all(nodesChunk.map(async (node) => {
-            const signedKey = getBinaryNodeChild(node, 'skey');
-            const key = getBinaryNodeChild(node, 'key');
-            const identity = getBinaryNodeChildBuffer(node, 'identity');
-            const jid = node.attrs.jid;
-            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4);
-            await repository.injectE2ESession({
-                jid,
-                session: {
-                    registrationId: registrationId,
-                    identityKey: generateSignalPubKey(identity),
-                    signedPreKey: extractKey(signedKey),
-                    preKey: extractKey(key)
-                }
-            });
-        }));
+        (0, WABinary_1.assertNodeErrorFree)(node);
     }
+    await Promise.all(nodes.map(async (node) => {
+        const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
+        const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
+        const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
+        const jid = node.attrs.jid;
+        const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
+        await repository.injectE2ESession({
+            jid,
+            session: {
+                registrationId: registrationId,
+                identityKey: (0, crypto_1.generateSignalPubKey)(identity),
+                signedPreKey: extractKey(signedKey),
+                preKey: extractKey(key)
+            }
+        });
+    }));
 };
-export const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = jidDecode(myJid);
+exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
+const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
     const extracted = [];
     for (const userResult of result) {
         const { devices, id } = userResult;
-        const { user } = jidDecode(id);
-        const deviceList = devices?.deviceList;
+        const { user } = (0, WABinary_1.jidDecode)(id);
+        const deviceList = devices === null || devices === void 0 ? void 0 : devices.deviceList;
         if (Array.isArray(deviceList)) {
             for (const { id: device, keyIndex } of deviceList) {
                 if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
@@ -113,38 +104,40 @@ export const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
     }
     return extracted;
 };
+exports.extractDeviceJids = extractDeviceJids;
 /**
  * get the next N keys for upload or processing
  * @param count number of pre-keys to get or generate
  */
-export const getNextPreKeys = async ({ creds, keys }, count) => {
-    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count);
+const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = (0, exports.generateOrGetPreKeys)(creds, count);
     const update = {
         nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
         firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
     };
     await keys.set({ 'pre-key': newPreKeys });
-    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    const preKeys = await (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
     return { update, preKeys };
 };
-export const getNextPreKeysNode = async (state, count) => {
+exports.getNextPreKeys = getNextPreKeys;
+const getNextPreKeysNode = async (state, count) => {
     const { creds } = state;
-    const { update, preKeys } = await getNextPreKeys(state, count);
+    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
     const node = {
         tag: 'iq',
         attrs: {
             xmlns: 'encrypt',
             type: 'set',
-            to: S_WHATSAPP_NET
+            to: WABinary_1.S_WHATSAPP_NET,
         },
         content: [
-            { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
+            { tag: 'registration', attrs: {}, content: (0, generics_1.encodeBigEndian)(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
             { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
-            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
-            xmppSignedPreKey(creds.signedPreKey)
+            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
+            (0, exports.xmppSignedPreKey)(creds.signedPreKey)
         ]
     };
     return { update, node };
 };
-//# sourceMappingURL=signal.js.map
+exports.getNextPreKeysNode = getNextPreKeysNode;

package/lib/Utils/use-multi-file-auth-state.js

@@ -1,27 +1,44 @@
-import fs from 'fs';
-import { join } from 'path';
-import { proto } from '../../WAProto/index.js';
-import { initAuthCreds } from './auth-utils.js';
-import { BufferJSON } from './generics.js';
-export const useMultiFileAuthState = async (folder) => {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function(mod) {
+	return (mod && mod.__esModule) ? mod : {
+		"default": mod
+	};
+};
+Object.defineProperty(exports, "__esModule", {
+	value: true
+});
+exports.useMultiFileAuthState = void 0;
+const fs = require("fs");
+const path_1 = require("path");
+const WAProto_1 = require("../../WAProto");
+const auth_utils_1 = require("./auth-utils");
+const generics_1 = require("./generics");
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+const useMultiFileAuthState = async (folder) => {
 	const writeData = async (data, file) => {
-		const filePath = await (0, join)(folder, fixFileName(file));
-		return (0, fs.writeFileSync)((0, join)(filePath), JSON.stringify(data, BufferJSON.replacer));
+		const filePath = await (0, path_1.join)(folder, fixFileName(file));
+		return (0, fs.writeFileSync)((0, path_1.join)(filePath), JSON.stringify(data, generics_1.BufferJSON.replacer));
 	};
 	const readData = async (file) => {
 		try {
-			const filePath = await (0, join)(folder, fixFileName(file));
+			const filePath = await (0, path_1.join)(folder, fixFileName(file));
 			const data = (0, fs.readFileSync)(filePath, {
 				encoding: 'utf-8'
 			});
-			return JSON.parse(data, BufferJSON.reviver);
+			return JSON.parse(data, generics_1.BufferJSON.reviver);
 		} catch (e) {
 			return null;
 		}
 	};
 	const removeData = async (file) => {
 		try {
-			const filePath = await (0, join)(folder, fixFileName(file));
+			const filePath = await (0, path_1.join)(folder, fixFileName(file));
 			(0, fs.unlinkSync)(filePath);
 		} catch (_a) {}
 	};
@@ -39,7 +56,7 @@ export const useMultiFileAuthState = async (folder) => {
 		var _a;
 		return (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.replace(/:/g, '-');
 	};
-	const creds = await readData('creds.json') || await (0, await initAuthCreds)();
+	const creds = await readData('creds.json') || await (0, await auth_utils_1.initAuthCreds)();
 	return {
 		state: {
 			creds,
@@ -49,7 +66,7 @@ export const useMultiFileAuthState = async (folder) => {
 					await Promise.all(ids.map(async (id) => {
 						let value = await readData(`${type}-${id}.json`);
 						if (type === 'app-state-sync-key' && value) {
-							value = proto.Message.AppStateSyncKeyData.fromObject(value);
+							value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
 						}
 						data[id] = value;
 					}));
@@ -72,4 +89,5 @@ export const useMultiFileAuthState = async (folder) => {
 			return writeData(creds, 'creds.json');
 		}
 	};
-};
+};
+exports.useMultiFileAuthState = useMultiFileAuthState;

package/lib/Utils/validate-connection.js

@@ -1,35 +1,47 @@
-import { Boom } from '@hapi/boom';
-import { createHash } from 'crypto';
-import { proto } from '../../WAProto/index.js';
-import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
-import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
-import { Curve, hmacSign } from './crypto.js';
-import { encodeBigEndian } from './generics.js';
-import { createSignalIdentity } from './signal.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeSignedDeviceIdentity = exports.configureSuccessfulPairing = exports.generateRegistrationNode = exports.generateLoginNode = exports.generateMobileNode = void 0;
+const boom_1 = require("@hapi/boom");
+const crypto_1 = require("crypto");
+const WAProto_1 = require("../../WAProto");
+const Defaults_1 = require("../Defaults");
+const WABinary_1 = require("../WABinary");
+const crypto_2 = require("./crypto");
+const generics_1 = require("./generics");
+const signal_1 = require("./signal");
 const getUserAgent = (config) => {
+    var _a, _b;
+    const osVersion = config.mobile ? '15.3.1' : '0.1';
+    const version = config.mobile ? [2, 24, 6] : config.version;
+    const device = config.mobile ? 'iPhone_7' : 'Desktop';
+    const manufacturer = config.mobile ? 'Apple' : '';
+    const platform = config.mobile ? WAProto_1.proto.ClientPayload.UserAgent.Platform.IOS : WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB;
+    const phoneId = config.mobile ? { phoneId: config.auth.creds.phoneId } : {};
     return {
         appVersion: {
-            primary: config.version[0],
-            secondary: config.version[1],
-            tertiary: config.version[2]
+            primary: version[0],
+            secondary: version[1],
+            tertiary: version[2],
         },
-        platform: proto.ClientPayload.UserAgent.Platform.WEB,
-        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
-        osVersion: '0.1',
-        device: 'Desktop',
-        osBuildNumber: '0.1',
+        platform,
+        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        mcc: ((_a = config.auth.creds.registration) === null || _a === void 0 ? void 0 : _a.phoneNumberMobileCountryCode) || '000',
+        mnc: ((_b = config.auth.creds.registration) === null || _b === void 0 ? void 0 : _b.phoneNumberMobileNetworkCode) || '000',
+        osVersion: osVersion,
+        manufacturer,
+        device,
+        osBuildNumber: osVersion,
         localeLanguageIso6391: 'en',
-        mnc: '000',
-        mcc: '000',
-        localeCountryIso31661Alpha2: config.countryCode
+        localeCountryIso31661Alpha2: config.countryCode,
+        ...phoneId
     };
 };
 const PLATFORM_MAP = {
-    'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+    'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    'Windows': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
 };
 const getWebInfo = (config) => {
-    let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    let webSubPlatform = WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
     if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]]) {
         webSubPlatform = PLATFORM_MAP[config.browser[0]];
     }
@@ -37,41 +49,64 @@ const getWebInfo = (config) => {
 };
 const getClientPayload = (config) => {
     const payload = {
-        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-        userAgent: getUserAgent(config)
+        connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config),
     };
-    payload.webInfo = getWebInfo(config);
+    if (!config.mobile) {
+        payload.webInfo = getWebInfo(config);
+    }
     return payload;
 };
-export const generateLoginNode = (userJid, config) => {
-    const { user, device } = jidDecode(userJid);
+const generateMobileNode = (config) => {
+    if (!config.auth.creds) {
+        throw new boom_1.Boom('No registration data found', { data: config });
+    }
+    const payload = {
+        ...getClientPayload(config),
+        sessionId: Math.floor(Math.random() * 999999999 + 1),
+        shortConnect: true,
+        connectAttemptCount: 0,
+        device: 0,
+        dnsSource: {
+            appCached: false,
+            dnsMethod: WAProto_1.proto.ClientPayload.DNSSource.DNSResolutionMethod.SYSTEM,
+        },
+        passive: false, // XMPP heartbeat setting (false: server actively pings) (true: client actively pings)
+        pushName: 'test',
+        username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`),
+    };
+    return WAProto_1.proto.ClientPayload.fromObject(payload);
+};
+exports.generateMobileNode = generateMobileNode;
+const generateLoginNode = (userJid, config) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(userJid);
     const payload = {
         ...getClientPayload(config),
         passive: false,
         pull: true,
         username: +user,
-        device: device
+        device: device,
     };
-    return proto.ClientPayload.fromObject(payload);
+    return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
+exports.generateLoginNode = generateLoginNode;
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase();
-    return (proto.DeviceProps.PlatformType[platformType] ||
-        proto.DeviceProps.PlatformType.DESKTOP);
+    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.DESKTOP;
 };
-export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
     // the app version needs to be md5 hashed
     // and passed in
-    const appVersionBuf = createHash('md5')
+    const appVersionBuf = (0, crypto_1.createHash)('md5')
         .update(config.version.join('.')) // join as string
         .digest();
     const companion = {
         os: config.browser[0],
         platformType: getPlatformType(config.browser[1]),
-        requireFullSync: config.syncFullHistory
+        requireFullSync: config.syncFullHistory,
     };
-    const companionProto = proto.DeviceProps.encode(companion).finish();
+    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish();
     const registerPayload = {
         ...getClientPayload(config),
         passive: false,
@@ -79,53 +114,54 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
-            eRegid: encodeBigEndian(registrationId),
-            eKeytype: KEY_BUNDLE_TYPE,
+            eRegid: (0, generics_1.encodeBigEndian)(registrationId),
+            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
             eIdent: signedIdentityKey.public,
-            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
+            eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
-            eSkeySig: signedPreKey.signature
-        }
+            eSkeySig: signedPreKey.signature,
+        },
     };
-    return proto.ClientPayload.fromObject(registerPayload);
+    return WAProto_1.proto.ClientPayload.fromObject(registerPayload);
 };
-export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+exports.generateRegistrationNode = generateRegistrationNode;
+const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
     const msgId = stanza.attrs.id;
-    const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success');
-    const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity');
-    const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform');
-    const deviceNode = getBinaryNodeChild(pairSuccessNode, 'device');
-    const businessNode = getBinaryNodeChild(pairSuccessNode, 'biz');
+    const pairSuccessNode = (0, WABinary_1.getBinaryNodeChild)(stanza, 'pair-success');
+    const deviceIdentityNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device-identity');
+    const platformNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'platform');
+    const deviceNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device');
+    const businessNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'biz');
     if (!deviceIdentityNode || !deviceNode) {
-        throw new Boom('Missing device-identity or device in pair success node', { data: stanza });
+        throw new boom_1.Boom('Missing device-identity or device in pair success node', { data: stanza });
     }
-    const bizName = businessNode?.attrs.name;
+    const bizName = businessNode === null || businessNode === void 0 ? void 0 : businessNode.attrs.name;
     const jid = deviceNode.attrs.jid;
-    const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
-    const isHostedAccount = accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED;
-    const hmacPrefix = isHostedAccount ? Buffer.from([6, 5]) : Buffer.alloc(0);
-    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    const { details, hmac } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    // check HMAC matches
+    const advSign = (0, crypto_2.hmacSign)(details, Buffer.from(advSecretKey, 'base64'));
     if (Buffer.compare(hmac, advSign) !== 0) {
-        throw new Boom('Invalid account signature');
+        throw new boom_1.Boom('Invalid account signature');
     }
-    const account = proto.ADVSignedDeviceIdentity.decode(details);
+    const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details);
     const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
+    // verify the device signature matches
     const accountMsg = Buffer.concat([Buffer.from([6, 0]), deviceDetails, signedIdentityKey.public]);
-    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
-        throw new Boom('Failed to verify account signature');
+    if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new boom_1.Boom('Failed to verify account signature');
     }
-    const devicePrefix = isHostedAccount ? Buffer.from([6, 6]) : Buffer.from([6, 1]);
-    const deviceMsg = Buffer.concat([devicePrefix, deviceDetails, signedIdentityKey.public, accountSignatureKey]);
-    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
-    const identity = createSignalIdentity(jid, accountSignatureKey);
-    const accountEnc = encodeSignedDeviceIdentity(account, false);
-    const deviceIdentity = proto.ADVDeviceIdentity.decode(account.details);
+    // sign the details with our identity key
+    const deviceMsg = Buffer.concat([Buffer.from([6, 1]), deviceDetails, signedIdentityKey.public, accountSignatureKey]);
+    account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = (0, signal_1.createSignalIdentity)(jid, accountSignatureKey);
+    const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false);
+    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(account.details);
     const reply = {
         tag: 'iq',
         attrs: {
-            to: S_WHATSAPP_NET,
+            to: WABinary_1.S_WHATSAPP_NET,
             type: 'result',
-            id: msgId
+            id: msgId,
         },
         content: [
             {
@@ -144,21 +180,28 @@ export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentit
     const authUpdate = {
         account,
         me: { id: jid, name: bizName },
-        signalIdentities: [...(signalIdentities || []), identity],
-        platform: platformNode?.attrs.name
+        signalIdentities: [
+            ...(signalIdentities || []),
+            identity
+        ],
+        platform: platformNode === null || platformNode === void 0 ? void 0 : platformNode.attrs.name
     };
     return {
         creds: authUpdate,
         reply
     };
 };
-export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+exports.configureSuccessfulPairing = configureSuccessfulPairing;
+const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    var _a;
     account = { ...account };
     // set to null if we are not to include the signature key
     // or if we are including the signature key but it is empty
-    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+    if (!includeSignatureKey || !((_a = account.accountSignatureKey) === null || _a === void 0 ? void 0 : _a.length)) {
         account.accountSignatureKey = null;
     }
-    return proto.ADVSignedDeviceIdentity.encode(account).finish();
+    return WAProto_1.proto.ADVSignedDeviceIdentity
+        .encode(account)
+        .finish();
 };
-//# sourceMappingURL=validate-connection.js.map
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;