@alannxd/baileys 6.0.6 → 6.0.9

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,163 @@
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false; // PSA
+    if (BOT_PHONE_REGEX.test(user))
+        return false; // Bot by phone pattern
+    if (isJidMetaAI(jid))
+        return false; // MetaAI (@bot server)
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY = '__index';
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
+    const entry = data[TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length)
+        return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+export function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined)
+        return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts))
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+export function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined)
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared = entry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode)
+        return;
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}
+//# sourceMappingURL=tc-token-utils.js.map

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

@@ -1,17 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useMultiFileAuthState = void 0;
-const async_mutex_1 = require("async-mutex");
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const WAProto_1 = require("../../WAProto");
-const auth_utils_1 = require("./auth-utils");
-const generics_1 = require("./generics");
+import { Mutex } from 'async-mutex';
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
 const fileLocks = new Map();
+// Get or create a mutex for a specific file path
 const getFileLock = (path) => {
     let mutex = fileLocks.get(path);
     if (!mutex) {
-        mutex = new async_mutex_1.Mutex();
+        mutex = new Mutex();
         fileLocks.set(path, mutex);
     }
     return mutex;
@@ -23,13 +25,14 @@ const getFileLock = (path) => {
  * 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) => {
+export const useMultiFileAuthState = async (folder) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const writeData = async (data, file) => {
-        const filePath = (0, path_1.join)(folder, fixFileName(file));
+        const filePath = join(folder, fixFileName(file));
         const mutex = getFileLock(filePath);
         return mutex.acquire().then(async (release) => {
             try {
-                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer));
+                await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
             }
             finally {
                 release();
@@ -38,12 +41,12 @@ const useMultiFileAuthState = async (folder) => {
     };
     const readData = async (file) => {
         try {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const filePath = join(folder, fixFileName(file));
             const mutex = getFileLock(filePath);
             return await mutex.acquire().then(async (release) => {
                 try {
-                    const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
-                    return JSON.parse(data, generics_1.BufferJSON.reviver);
+                    const data = await readFile(filePath, { encoding: 'utf-8' });
+                    return JSON.parse(data, BufferJSON.reviver);
                 }
                 finally {
                     release();
@@ -56,33 +59,32 @@ const useMultiFileAuthState = async (folder) => {
     };
     const removeData = async (file) => {
         try {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const filePath = join(folder, fixFileName(file));
             const mutex = getFileLock(filePath);
             return mutex.acquire().then(async (release) => {
                 try {
-                    await (0, promises_1.unlink)(filePath);
+                    await unlink(filePath);
                 }
-                catch (_a) {
+                catch {
                 }
                 finally {
                     release();
                 }
             });
         }
-        catch (_a) {
-        }
+        catch { }
     };
-    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
+    const folderInfo = await stat(folder).catch(() => { });
     if (folderInfo) {
         if (!folderInfo.isDirectory()) {
             throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
         }
     }
     else {
-        await (0, promises_1.mkdir)(folder, { recursive: true });
+        await mkdir(folder, { recursive: true });
     }
-    const fixFileName = (file) => { 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') || (0, auth_utils_1.initAuthCreds)();
+    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
+    const creds = (await readData('creds.json')) || initAuthCreds();
     return {
         state: {
             creds,
@@ -92,7 +94,7 @@ 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 = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
                         }
                         data[id] = value;
                     }));
@@ -116,4 +118,4 @@ const useMultiFileAuthState = async (folder) => {
         }
     };
 };
-exports.useMultiFileAuthState = useMultiFileAuthState;
+//# sourceMappingURL=use-multi-file-auth-state.js.map

package/lib/Utils/validate-connection.js

@@ -1,81 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeSignedDeviceIdentity = exports.configureSuccessfulPairing = exports.generateRegistrationNode = exports.generateLoginNode = 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");
-
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { KEY_BUNDLE_TYPE, WA_ADV_ACCOUNT_SIG_PREFIX, WA_ADV_DEVICE_SIG_PREFIX, WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX } 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';
 const getUserAgent = (config) => {
     return {
         appVersion: {
             primary: config.version[0],
             secondary: config.version[1],
-            tertiary: config.version[2],
+            tertiary: config.version[2]
         },
-        platform: "MACOS",
-        releaseChannel: "RELEASE",
+        platform: proto.ClientPayload.UserAgent.Platform.MACOS,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         osVersion: '0.1',
         device: 'Desktop',
         osBuildNumber: '0.1',
         localeLanguageIso6391: 'en',
         mnc: '000',
         mcc: '000',
-        localeCountryIso31661Alpha2: config.countryCode || 'US'
+        localeCountryIso31661Alpha2: config.countryCode
     };
 };
-
 const PLATFORM_MAP = {
-    'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    'Windows': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+    'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
 };
-
 const getWebInfo = (config) => {
-    let webSubPlatform = WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
-    if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]] && config.browser[1] === 'Desktop') {
+    let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    if (config.syncFullHistory &&
+        PLATFORM_MAP[config.browser[0]] &&
+        config.browser[1] === 'Desktop') {
         webSubPlatform = PLATFORM_MAP[config.browser[0]];
     }
     return { webSubPlatform };
 };
-
 const getClientPayload = (config) => {
     const payload = {
-        connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-        userAgent: getUserAgent(config),
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
     };
     payload.webInfo = getWebInfo(config);
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
     return payload;
 };
-
-const generateLoginNode = (userJid, config) => {
-    const { user, device } = (0, WABinary_1.jidDecode)(userJid);
+export const generateLoginNode = (userJid, config) => {
+    const { user, device } = jidDecode(userJid);
     const payload = {
         ...getClientPayload(config),
         passive: true,
         pull: true,
         username: +user,
         device: device,
+        // TODO: investigate (hard set as false atm)
         lidDbMigrated: false
     };
-    return WAProto_1.proto.ClientPayload.fromObject(payload);
+    return proto.ClientPayload.fromObject(payload);
 };
-exports.generateLoginNode = generateLoginNode;
-
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase();
-    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.CHROME;
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.CHROME);
 };
-
-const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
-    const appVersionBuf = (0, crypto_1.createHash)('md5')
-        .update(config.version.join('.'))
+export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    // the app version needs to be md5 hashed
+    // and passed in
+    const appVersionBuf = createHash('md5')
+        .update(config.version.join('.')) // join as string
         .digest();
-
     const companion = {
         os: config.browser[0],
         platformType: getPlatformType(config.browser[1]),
@@ -103,9 +100,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
             tertiary: 7
         }
     };
-
-    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish();
-
+    const companionProto = proto.DeviceProps.encode(companion).finish();
     const registerPayload = {
         ...getClientPayload(config),
         passive: false,
@@ -113,77 +108,63 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
-            eRegid: (0, generics_1.encodeBigEndian)(registrationId),
-            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
             eIdent: signedIdentityKey.public,
-            eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
-            eSkeySig: signedPreKey.signature,
-        },
+            eSkeySig: signedPreKey.signature
+        }
     };
-    return WAProto_1.proto.ClientPayload.fromObject(registerPayload);
+    return proto.ClientPayload.fromObject(registerPayload);
 };
-exports.generateRegistrationNode = generateRegistrationNode;
-
-const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
     const msgId = stanza.attrs.id;
-    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');
-
+    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');
     if (!deviceIdentityNode || !deviceNode) {
-        throw new boom_1.Boom('Missing device-identity or device in pair success node', { data: stanza });
+        throw new Boom('Missing device-identity or device in pair success node', { data: stanza });
     }
-
     const bizName = businessNode?.attrs.name;
     const jid = deviceNode.attrs.jid;
     const lid = deviceNode.attrs.lid;
-
-    const { details, hmac, accountType } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
-
+    const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
     let hmacPrefix = Buffer.from([]);
-    if (accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED) {
-        hmacPrefix = Buffer.from([0x06, 0x05]);
+    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
     }
-
-    const advSign = (0, crypto_2.hmacSign)(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
     if (Buffer.compare(hmac, advSign) !== 0) {
-        throw new boom_1.Boom('Invalid account signature');
+        throw new Boom('Invalid account signature');
     }
-
-    const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details);
+    const account = proto.ADVSignedDeviceIdentity.decode(details);
     const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
-
-    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(deviceDetails);
-
-    const accountSignaturePrefix = deviceIdentity.deviceType === WAProto_1.proto.ADVEncryptionType.HOSTED 
-        ? Buffer.from([0x06, 0x05])
-        : Buffer.from([0x06, 0x00]);
+    const deviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails);
+    const accountSignaturePrefix = deviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
+        ? WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : WA_ADV_ACCOUNT_SIG_PREFIX;
     const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
-    
-    if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
-        throw new boom_1.Boom('Failed to verify account signature');
+    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new Boom('Failed to verify account signature');
     }
-
     const deviceMsg = Buffer.concat([
-        Buffer.from([0x06, 0x01]),
+        WA_ADV_DEVICE_SIG_PREFIX,
         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);
-
+    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = createSignalIdentity(lid, accountSignatureKey);
+    const accountEnc = encodeSignedDeviceIdentity(account, false);
     const reply = {
         tag: 'iq',
         attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: S_WHATSAPP_NET,
             type: 'result',
-            id: msgId,
+            id: msgId
         },
         content: [
             {
@@ -199,31 +180,24 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
             }
         ]
     };
-
     const authUpdate = {
         account,
         me: { id: jid, name: bizName, lid },
-        signalIdentities: [
-            ...(signalIdentities || []),
-            identity
-        ],
+        signalIdentities: [...(signalIdentities || []), identity],
         platform: platformNode?.attrs.name
     };
-
     return {
         creds: authUpdate,
         reply
     };
 };
-exports.configureSuccessfulPairing = configureSuccessfulPairing;
-
-const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
     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) {
         account.accountSignatureKey = null;
     }
-    return WAProto_1.proto.ADVSignedDeviceIdentity
-        .encode(account)
-        .finish();
+    return proto.ADVSignedDeviceIdentity.encode(account).finish();
 };
-exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;
+//# sourceMappingURL=validate-connection.js.map