jagproject 26.3.22 → 26.3.25

package/lib/Utils/sync-action-utils.d.ts

@@ -0,0 +1,19 @@
+import { proto } from '../../WAProto/index.js';
+import type { BaileysEventEmitter, BaileysEventMap, Contact } from '../Types/index.js';
+import type { ILogger } from './logger.js';
+export type ContactsUpsertResult = {
+    event: 'contacts.upsert';
+    data: Contact[];
+};
+export type LidMappingUpdateResult = {
+    event: 'lid-mapping.update';
+    data: BaileysEventMap['lid-mapping.update'];
+};
+export type SyncActionResult = ContactsUpsertResult | LidMappingUpdateResult;
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
+export declare const processContactAction: (action: proto.SyncActionValue.IContactAction, id: string | undefined, logger?: ILogger) => SyncActionResult[];
+export declare const emitSyncActionResults: (ev: BaileysEventEmitter, results: SyncActionResult[]) => void;
+//# sourceMappingURL=sync-action-utils.d.ts.map

package/lib/Utils/sync-action-utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitSyncActionResults = exports.processContactAction = void 0;
+const index_js_1 = require("../../WAProto/index.js");
+const index_js_2 = require("../WABinary/index.js");
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
+const processContactAction = (action, id, logger) => {
+    const results = [];
+    if (!id) {
+        logger?.warn({ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid }, 'contactAction sync: missing id in index');
+        return results;
+    }
+    const lidJid = action.lidJid;
+    const idIsPn = (0, index_js_2.isPnUser)(id);
+    // PN is in index[1], not in contactAction.pnJid which is usually null
+    const phoneNumber = idIsPn ? id : action.pnJid || undefined;
+    // Always emit contacts.upsert
+    results.push({
+        event: 'contacts.upsert',
+        data: [
+            {
+                id,
+                name: action.fullName || action.firstName || action.username || undefined,
+                lid: lidJid || undefined,
+                phoneNumber
+            }
+        ]
+    });
+    // Emit lid-mapping.update if we have valid LID-PN pair
+    if (lidJid && (0, index_js_2.isLidUser)(lidJid) && idIsPn) {
+        results.push({
+            event: 'lid-mapping.update',
+            data: { lid: lidJid, pn: id }
+        });
+    }
+    return results;
+};
+exports.processContactAction = processContactAction;
+const emitSyncActionResults = (ev, results) => {
+    for (const result of results) {
+        if (result.event === 'contacts.upsert') {
+            ev.emit('contacts.upsert', result.data);
+        }
+        else {
+            ev.emit('lid-mapping.update', result.data);
+        }
+    }
+};
+exports.emitSyncActionResults = emitSyncActionResults;

package/lib/Utils/tc-token-utils.d.ts

@@ -0,0 +1,12 @@
+import type { SignalKeyStoreWithTransaction } from '../Types/index.js';
+import type { BinaryNode } from '../WABinary/index.js';
+type TcTokenParams = {
+    jid: string;
+    baseContent?: BinaryNode[];
+    authState: {
+        keys: SignalKeyStoreWithTransaction;
+    };
+};
+export declare function buildTcTokenFromJid({ authState, jid, baseContent }: TcTokenParams): Promise<BinaryNode[] | undefined>;
+export {};
+//# sourceMappingURL=tc-token-utils.d.ts.map

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTcTokenFromJid = buildTcTokenFromJid;
+async function buildTcTokenFromJid({ authState, jid, baseContent = [] }) {
+    try {
+        const tcTokenData = await authState.keys.get('tctoken', [jid]);
+        const tcTokenBuffer = tcTokenData?.[jid]?.token;
+        if (!tcTokenBuffer)
+            return baseContent.length > 0 ? baseContent : undefined;
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMongoFileAuthState = void 0;
+const index_js_1 = require("../../WAProto/index.js");
+const auth_utils_js_1 = require("./auth-utils.js");
+const generics_js_1 = require("./generics.js");
+/*
+code from amiruldev readjusted by @irull2nd, don't delete WM!
+*/
+const useMongoFileAuthState = async (collection) => {
+    const writeData = (data, id) => {
+        const informationToStore = JSON.parse(JSON.stringify(data, generics_js_1.BufferJSON.replacer));
+        const update = {
+            $set: {
+                ...informationToStore,
+            },
+        };
+        return collection.updateOne({ _id: id }, update, { upsert: true });
+    };
+    const readData = async (id) => {
+        try {
+            const data = JSON.stringify(await collection.findOne({ _id: id }));
+            return JSON.parse(data, generics_js_1.BufferJSON.reviver);
+        }
+        catch (err) {
+            console.log(err);
+        }
+    };
+    const removeData = async (id) => {
+        try {
+            await collection.deleteOne({ _id: id });
+        }
+        catch (err) {
+            console.log('error', err);
+        }
+    };
+    const creds = (await readData('creds')) || (0, auth_utils_js_1.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}`);
+                        if (type === 'app-state-sync-key') {
+                            value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(data);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category of Object.keys(data)) {
+                        for (const id of Object.keys(data[category])) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? writeData(value, key) : removeData(key));
+                        }
+                    }
+                    await Promise.all(tasks);
+                },
+            },
+        },
+        saveCreds: () => {
+            return writeData(creds, 'creds');
+        }
+    };
+};
+exports.useMongoFileAuthState = useMongoFileAuthState;

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,13 @@
+import type { AuthenticationState } from '../Types/index.js';
+/**
+ * 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
+ * */
+export declare const useMultiFileAuthState: (folder: string) => Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+}>;
+//# sourceMappingURL=use-multi-file-auth-state.d.ts.map

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

@@ -4,11 +4,11 @@ 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");
+const index_js_1 = require("../../WAProto/index.js");
+const auth_utils_js_1 = require("./auth-utils.js");
+const generics_js_1 = require("./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/Wileys/issues/794
+// 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();
@@ -35,7 +35,7 @@ const useMultiFileAuthState = async (folder) => {
         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 (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_js_1.BufferJSON.replacer));
             }
             finally {
                 release();
@@ -49,7 +49,7 @@ const useMultiFileAuthState = async (folder) => {
             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);
+                    return JSON.parse(data, generics_js_1.BufferJSON.reviver);
                 }
                 finally {
                     release();
@@ -68,15 +68,14 @@ const useMultiFileAuthState = async (folder) => {
                 try {
                     await (0, promises_1.unlink)(filePath);
                 }
-                catch (_a) {
+                catch {
                 }
                 finally {
                     release();
                 }
             });
         }
-        catch (_a) {
-        }
+        catch { }
     };
     const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
     if (folderInfo) {
@@ -87,8 +86,8 @@ const useMultiFileAuthState = async (folder) => {
     else {
         await (0, promises_1.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')) || (0, auth_utils_js_1.initAuthCreds)();
     return {
         state: {
             creds,
@@ -98,7 +97,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 = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value);
                         }
                         data[id] = value;
                     }));

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSingleFileAuthState = void 0;
+const index_js_1 = require("../../WAProto/index.js");
+const auth_utils_js_1 = require("./auth-utils.js");
+const generics_js_1 = require("./generics.js");
+// useless key map only there to maintain backwards compatibility
+// do not use in your own systems please
+const KEY_MAP = {
+    'pre-key': 'preKeys',
+    'session': 'sessions',
+    'sender-key': 'senderKeys',
+    'app-state-sync-key': 'appStateSyncKeys',
+    'app-state-sync-version': 'appStateVersions',
+    'sender-key-memory': 'senderKeyMemory'
+};
+/**
+ * @deprecated use multi file auth state instead please
+ * stores the full authentication state in a single JSON file
+ *
+ * DO NOT USE IN A PROD ENVIRONMENT, only meant to serve as an example
+ * */
+const useSingleFileAuthState = (filename, logger) => {
+    const { readFileSync, writeFileSync, existsSync } = require('fs');
+    let creds;
+    let keys = {};
+    // save the authentication state to a file
+    const saveState = () => {
+        logger && logger.trace('saving auth state');
+        writeFileSync(filename, 
+        // BufferJSON replacer utility saves buffers nicely
+        JSON.stringify({ creds, keys }, generics_js_1.BufferJSON.replacer, 2));
+    };
+    if (existsSync(filename)) {
+        const result = JSON.parse(readFileSync(filename, { encoding: 'utf-8' }), generics_js_1.BufferJSON.reviver);
+        creds = result.creds;
+        keys = result.keys;
+    }
+    else {
+        creds = (0, auth_utils_js_1.initAuthCreds)();
+        keys = {};
+    }
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const key = KEY_MAP[type];
+                    return ids.reduce((dict, id) => {
+                        let value = keys[key]?.[id];
+                        if (value) {
+                            if (type === 'app-state-sync-key') {
+                                value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            dict[id] = value;
+                        }
+                        return dict;
+                    }, {});
+                },
+                set: (data) => {
+                    for (const _key in data) {
+                        const key = KEY_MAP[_key];
+                        keys[key] = keys[key] || {};
+                        Object.assign(keys[key], data[_key]);
+                    }
+                    saveState();
+                }
+            }
+        },
+        saveState
+    };
+};
+exports.useSingleFileAuthState = useSingleFileAuthState;

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,11 @@
+import { proto } from '../../WAProto/index.js';
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types/index.js';
+import { type BinaryNode } from '../WABinary/index.js';
+export declare const generateLoginNode: (userJid: string, config: SocketConfig) => proto.IClientPayload;
+export declare const generateRegistrationNode: ({ registrationId, signedPreKey, signedIdentityKey }: SignalCreds, config: SocketConfig) => proto.ClientPayload;
+export declare const configureSuccessfulPairing: (stanza: BinaryNode, { advSecretKey, signedIdentityKey, signalIdentities }: Pick<AuthenticationCreds, "advSecretKey" | "signedIdentityKey" | "signalIdentities">) => {
+    creds: Partial<AuthenticationCreds>;
+    reply: BinaryNode;
+};
+export declare const encodeSignedDeviceIdentity: (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => Uint8Array<ArrayBufferLike>;
+//# sourceMappingURL=validate-connection.d.ts.map

package/lib/Utils/validate-connection.js

@@ -3,79 +3,77 @@ 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");
-
+const index_js_1 = require("../../WAProto/index.js");
+const index_js_2 = require("../Defaults/index.js");
+const index_js_3 = require("../WABinary/index.js");
+const crypto_js_1 = require("./crypto.js");
+const generics_js_1 = require("./generics.js");
+const signal_js_1 = require("./signal.js");
 const getUserAgent = (config) => {
     return {
         appVersion: {
             primary: config.version[0],
             secondary: config.version[1],
-            tertiary: config.version[2],
+            tertiary: config.version[2]
         },
-        platform: WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB,
-        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        platform: index_js_1.proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: index_js_1.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': index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: index_js_1.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 = index_js_1.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: index_js_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: index_js_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
     };
     payload.webInfo = getWebInfo(config);
     return payload;
 };
-
 const generateLoginNode = (userJid, config) => {
-    const { user, device } = (0, WABinary_1.jidDecode)(userJid);
+    const { user, device } = (0, index_js_3.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 index_js_1.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 (index_js_1.proto.DeviceProps.PlatformType[platformType] ||
+        index_js_1.proto.DeviceProps.PlatformType.CHROME);
 };
-
 const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    // the app version needs to be md5 hashed
+    // and passed in
     const appVersionBuf = (0, crypto_1.createHash)('md5')
-        .update(config.version.join('.'))
+        .update(config.version.join('.')) // join as string
         .digest();
-
     const companion = {
         os: config.browser[0],
         platformType: getPlatformType(config.browser[1]),
@@ -103,9 +101,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
             tertiary: 7
         }
     };
-
-    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish();
-
+    const companionProto = index_js_1.proto.DeviceProps.encode(companion).finish();
     const registerPayload = {
         ...getClientPayload(config),
         passive: false,
@@ -113,77 +109,64 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
-            eRegid: (0, generics_1.encodeBigEndian)(registrationId),
-            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eRegid: (0, generics_js_1.encodeBigEndian)(registrationId),
+            eKeytype: index_js_2.KEY_BUNDLE_TYPE,
             eIdent: signedIdentityKey.public,
-            eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
+            eSkeyId: (0, generics_js_1.encodeBigEndian)(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
-            eSkeySig: signedPreKey.signature,
-        },
+            eSkeySig: signedPreKey.signature
+        }
     };
-    return WAProto_1.proto.ClientPayload.fromObject(registerPayload);
+    return index_js_1.proto.ClientPayload.fromObject(registerPayload);
 };
 exports.generateRegistrationNode = generateRegistrationNode;
-
 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 = (0, index_js_3.getBinaryNodeChild)(stanza, 'pair-success');
+    const deviceIdentityNode = (0, index_js_3.getBinaryNodeChild)(pairSuccessNode, 'device-identity');
+    const platformNode = (0, index_js_3.getBinaryNodeChild)(pairSuccessNode, 'platform');
+    const deviceNode = (0, index_js_3.getBinaryNodeChild)(pairSuccessNode, 'device');
+    const businessNode = (0, index_js_3.getBinaryNodeChild)(pairSuccessNode, 'biz');
     if (!deviceIdentityNode || !deviceNode) {
         throw new boom_1.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 } = index_js_1.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 === index_js_1.proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = index_js_2.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
     }
-
-    const advSign = (0, crypto_2.hmacSign)(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    const advSign = (0, crypto_js_1.hmacSign)(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
     if (Buffer.compare(hmac, advSign) !== 0) {
         throw new boom_1.Boom('Invalid account signature');
     }
-
-    const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details);
+    const account = index_js_1.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 = index_js_1.proto.ADVDeviceIdentity.decode(deviceDetails);
+    const accountSignaturePrefix = deviceIdentity.deviceType === index_js_1.proto.ADVEncryptionType.HOSTED
+        ? index_js_2.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : index_js_2.WA_ADV_ACCOUNT_SIG_PREFIX;
     const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
-    
-    if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+    if (!crypto_js_1.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
         throw new boom_1.Boom('Failed to verify account signature');
     }
-
     const deviceMsg = Buffer.concat([
-        Buffer.from([0x06, 0x01]),
+        index_js_2.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);
+    account.deviceSignature = crypto_js_1.Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = (0, signal_js_1.createSignalIdentity)(lid, accountSignatureKey);
     const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false);
-
     const reply = {
         tag: 'iq',
         attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: index_js_3.S_WHATSAPP_NET,
             type: 'result',
-            id: msgId,
+            id: msgId
         },
         content: [
             {
@@ -199,31 +182,25 @@ 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) => {
     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 index_js_1.proto.ADVSignedDeviceIdentity.encode(account).finish();
 };
-exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;