@hansaka02/baileys 7.3.2 → 7.3.6

package/lib/Utils/signal.js

@@ -2,16 +2,36 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const lodash_1 = require("lodash")
-const Defaults_1 = require("../Defaults")
-const WABinary_1 = require("../WABinary")
-const crypto_1 = require("./crypto")
-const generics_1 = require("./generics")
+const { KEY_BUNDLE_TYPE } = require("../Defaults/constants")
+const {
+  S_WHATSAPP_NET, 
+  getBinaryNodeChild, 
+  getBinaryNodeChildren, 
+  getBinaryNodeChildUInt, 
+  getBinaryNodeChildBuffer,
+  assertNodeErrorFree, 
+  jidDecode, 
+  getServerFromDomainType, 
+  WAJIDDomains, 
+} = require("../WABinary")
+const { 
+  Curve,
+  generateSignalPubKey 
+} = require("./crypto")
+const { encodeBigEndian } = require("./generics")
+
+function chunk(array, size) {
+    const chunks = []
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size))
+    }
+    return chunks
+}
 
 const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
         identifier: { name: wid, deviceId: 0 },
-        identifierKey: crypto_1.generateSignalPubKey(accountSignatureKey)
+        identifierKey: generateSignalPubKey(accountSignatureKey)
     }
 }
 
@@ -30,7 +50,7 @@ const generateOrGetPreKeys = (creds, range) => {
     const newPreKeys = {}
     if (remaining > 0) {
         for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = crypto_1.Curve.generateKeyPair()
+            newPreKeys[i] = Curve.generateKeyPair()
         }
     }
     return {
@@ -44,7 +64,7 @@ const xmppSignedPreKey = (key) => ({
     tag: 'skey',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(key.keyId, 3) },
+        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
         { tag: 'value', attrs: {}, content: key.keyPair.public },
         { tag: 'signature', attrs: {}, content: key.signature }
     ]
@@ -54,63 +74,81 @@ const xmppPreKey = (pair, id) => ({
     tag: 'key',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(id, 3) },
+        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
         { tag: 'value', attrs: {}, content: pair.public }
     ]
 })
 
 const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = (key) => (key ? ({
-        keyId: WABinary_1.getBinaryNodeChildUInt(key, 'id', 3),
-        publicKey: crypto_1.generateSignalPubKey(WABinary_1.getBinaryNodeChildBuffer(key, 'value')),
-        signature: WABinary_1.getBinaryNodeChildBuffer(key, 'signature')
-    }) : undefined)
-    const nodes = WABinary_1.getBinaryNodeChildren(WABinary_1.getBinaryNodeChild(node, 'list'), 'user')
+    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')
+    
     for (const node of nodes) {
-        WABinary_1.assertNodeErrorFree(node)
+        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 = lodash_1.chunk(nodes, chunkSize)
+    const chunks = chunk(nodes, chunkSize)
+    
     for (const nodesChunk of chunks) {
-        await Promise.all(nodesChunk.map(async (node) => {
-            const signedKey = WABinary_1.getBinaryNodeChild(node, 'skey')
-            const key = WABinary_1.getBinaryNodeChild(node, 'key')
-            const identity = WABinary_1.getBinaryNodeChildBuffer(node, 'identity')
+        for (const node of nodesChunk) {
+            const signedKey = getBinaryNodeChild(node, 'skey')
+            const key = getBinaryNodeChild(node, 'key')
+            const identity = getBinaryNodeChildBuffer(node, 'identity')
             const jid = node.attrs.jid
-            const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
+            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4)
             await repository.injectE2ESession({
                 jid,
                 session: {
                     registrationId: registrationId,
-                    identityKey: crypto_1.generateSignalPubKey(identity),
+                    identityKey: generateSignalPubKey(identity),
                     signedPreKey: extractKey(signedKey),
                     preKey: extractKey(key)
                 }
             })
-        }))
+        }
     }
 }
 
-const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
+const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = jidDecode(myJid)
     const extracted = []
+    
     for (const userResult of result) {
         const { devices, id } = userResult
-        const { user } = WABinary_1.jidDecode(id)
+        const decoded = jidDecode(id), { user, server } = decoded
+        
+        let { domainType } = decoded
+        
         const deviceList = 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
-                    (myUser !== user || myDevice !== device) && // either different user or if me user, not this device
-                    (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-                ) {
-                    extracted.push({ user, device })
+        
+        if (!Array.isArray(deviceList)) continue
+        
+        for (const { id: device, keyIndex, isHosted } of deviceList) {
+            if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+                ((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
+                (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+            ) {
+                if (isHosted) {
+                    domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED
                 }
+                extracted.push({
+                    user,
+                    device,
+                    domainType,
+                    server: getServerFromDomainType(server, domainType)
+                })
             }
         }
     }
@@ -140,11 +178,11 @@ const getNextPreKeysNode = async (state, count) => {
         attrs: {
             xmlns: 'encrypt',
             type: 'set',
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: S_WHATSAPP_NET,
         },
         content: [
-            { tag: 'registration', attrs: {}, content: generics_1.encodeBigEndian(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
+            { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: 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)

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

@@ -1,17 +1,13 @@
 "use strict"
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod }
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const async_mutex_1 = __importDefault(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 { Mutex } = require("async-mutex")
+const { promises } = require("fs")
+const { join } = require("path")
+const { proto } = require("../../WAProto")
+const { initAuthCreds } = require("./auth-utils")
+const { BufferJSON } = require("./generics")
 // 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
@@ -22,7 +18,7 @@ const fileLocks = new Map()
 const getFileLock = (path) => {
 	let mutex = fileLocks.get(path)
 	if (!mutex) {
-		mutex = new async_mutex_1.Mutex() 
+		mutex = new Mutex() 
 		fileLocks.set(path, mutex)
 	}
 
@@ -39,11 +35,11 @@ const getFileLock = (path) => {
 const useMultiFileAuthState = async (folder) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const writeData = async (data, file) => {
-        const filePath = path_1.join(folder, fixFileName(file))
+        const filePath = join(folder, fixFileName(file))
         const mutex = getFileLock(filePath)
         return mutex.acquire().then(async (release) => {
             try {
-               await promises_1.writeFile(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer))
+               await promises.writeFile(filePath, JSON.stringify(data, BufferJSON.replacer))
             } finally {
                 release()
             }
@@ -51,47 +47,47 @@ const useMultiFileAuthState = async (folder) => {
     }
     const readData = async (file) => {
         try {
-            const filePath = path_1.join(folder, fixFileName(file))
+            const filePath = join(folder, fixFileName(file))
             const mutex = getFileLock(filePath)
             const data = await mutex.acquire().then(async (release) => {
                 try {
-                    return await promises_1.readFile(filePath, { encoding: 'utf-8' })
+                    return await promises.readFile(filePath, { encoding: 'utf-8' })
                 } finally {
                     release()
                 }
             })
 
-            return JSON.parse(data, generics_1.BufferJSON.reviver)
+            return JSON.parse(data, BufferJSON.reviver)
         } catch (error) {
             return null
         }
     }
     const removeData = async (file) => {
         try {
-            const filePath = path_1.join(folder, fixFileName(file))
+            const filePath = join(folder, fixFileName(file))
             const mutex = getFileLock(filePath)
             await mutex.acquire().then(async (release) => {
                try {
-                    await promises_1.unlink(filePath)
+                    await promises.unlink(filePath)
                 } finally {
                     release()
                 }
             })
         } catch {}
     }
-    const folderInfo = await promises_1.stat(folder).catch(() => { })
+    const folderInfo = await promises.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 promises_1.mkdir(folder, { recursive: true })
+        await promises.mkdir(folder, { recursive: true })
     }
     const fixFileName = (file) => { 
         return file?.replace(/\//g, '__')?.replace(/:/g, '-') 
     }
-    const creds = await readData('creds.json') || auth_utils_1.initAuthCreds()
+    const creds = await readData('creds.json') || initAuthCreds()
     return {
         state: {
             creds,
@@ -101,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 = proto.Message.AppStateSyncKeyData.fromObject(value)
                         }
                         data[id] = value
                     }))

package/lib/Utils/validate-connection.js

@@ -2,14 +2,26 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-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 { Boom } = require("@hapi/boom")
+const { createHash } = require("crypto")
+const { proto } = require("../../WAProto")
+const {
+  KEY_BUNDLE_TYPE, 
+  WA_ADV_ACCOUNT_SIG_PREFIX, 
+  WA_ADV_DEVICE_SIG_PREFIX, 
+  WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+} = require("../Defaults/constants")
+const {
+  jidDecode, 
+  getBinaryNodeChild,
+  S_WHATSAPP_NET
+} = require("../WABinary")
+const {
+  Curve, 
+  hmacSign 
+} = require("./crypto")
+const { encodeBigEndian } = require("./generics")
+const { createSignalIdentity } = require("./signal")
 
 const getUserAgent = (config) => {
     return {
@@ -18,8 +30,10 @@ const getUserAgent = (config) => {
             secondary: config.version[1],
             tertiary: config.version[2],
         },
-        platform: WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB,
-        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        platform: /*config.browser[1].toLocaleLowerCase().includes('android') 
+                         ? proto.ClientPayload.UserAgent.Platform.ANDROID 
+                         :*/ proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         osVersion: '0.1',
         device: 'Desktop',
         osBuildNumber: '0.1',
@@ -31,14 +45,15 @@ const getUserAgent = (config) => {
 }
 
 const PLATFORM_MAP = {
-    'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    'Windows': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32, 
-    'Android': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID
+    '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]]) {
+    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 }
@@ -46,35 +61,48 @@ const getWebInfo = (config) => {
 
 const getClientPayload = (config) => {
     const payload = {
-        connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config),
     }
-    payload.webInfo = getWebInfo(config)
+    
+    /*if (!config.browser[1].toLocaleLowerCase().includes('android')) { 
+   	 payload.webInfo = getWebInfo(config) 
+    }*/
+    payload.webInfo = getWebInfo(config) 
+    
     return payload
 }
 
 const generateLoginNode = (userJid, config) => {
-    const { user, device } = WABinary_1.jidDecode(userJid)
+    const { user, device } = jidDecode(userJid)
     const payload = {
         ...getClientPayload(config),
-        passive: false,
+        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)
 }
 
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase()
-    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.DESKTOP
+    
+     /*if (platformType === 'ANDROID') { 
+     	return proto.DeviceProps.PlatformType.ANDROID_PHONE
+     }*/
+     
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.CHROME)
 }
 
 const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
     // the app version needs to be md5 hashed
     // and passed in
-    const appVersionBuf = crypto_1.createHash('md5')
+    const appVersionBuf = createHash('md5')
         .update(config.version.join('.')) // join as string
         .digest()
 
@@ -106,7 +134,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         }
     }
 
-    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish()
+    const companionProto = proto.DeviceProps.encode(companion).finish()
 
     const registerPayload = {
         ...getClientPayload(config),
@@ -115,73 +143,76 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
-            eRegid: generics_1.encodeBigEndian(registrationId),
-            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
             eIdent: signedIdentityKey.public,
-            eSkeyId: generics_1.encodeBigEndian(signedPreKey.keyId, 3),
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
             eSkeySig: signedPreKey.signature,
         }
     }
 
-    return WAProto_1.proto.ClientPayload.fromObject(registerPayload)
+    return proto.ClientPayload.fromObject(registerPayload)
 }
 
 const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
     const msgId = stanza.attrs.id
-    const pairSuccessNode = WABinary_1.getBinaryNodeChild(stanza, 'pair-success')
-    const deviceIdentityNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'device-identity')
-    const platformNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'platform')
-    const deviceNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'device')
-    const businessNode = 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 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([6, 5])
+    
+    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
     }
-
-    const advSign = 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 decodedDeviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(deviceDetails)
-
-    const accountSignaturePrefix =
-        decodedDeviceIdentity.deviceType === WAProto_1.proto.ADVEncryptionType.HOSTED
-            ? Buffer.from([6, 5])
-            : Buffer.from([6, 0])
+    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([6, 1]),
+        WA_ADV_DEVICE_SIG_PREFIX,
         deviceDetails,
         signedIdentityKey.public,
         accountSignatureKey
     ])
-    account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg)
-    const identity = signal_1.createSignalIdentity(lid, accountSignatureKey)
+    
+    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg)
+    
+    const identity = createSignalIdentity(lid, accountSignatureKey)
     const accountEnc = encodeSignedDeviceIdentity(account, false)
-    const deviceIdentityData = WAProto_1.proto.ADVDeviceIdentity.decode(account.details)
     const reply = {
         tag: 'iq',
         attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: S_WHATSAPP_NET,
             type: 'result',
-            id: msgId,
+            id: msgId
         },
         content: [
             {
@@ -190,22 +221,21 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
                 content: [
                     {
                         tag: 'device-identity',
-                        attrs: { 'key-index': deviceIdentityData.keyIndex.toString() },
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
                         content: accountEnc
                     }
                 ]
             }
         ]
     }
+    
     const authUpdate = {
         account,
         me: { id: jid, name: bizName, lid },
-        signalIdentities: [
-            ...(signalIdentities || []),
-            identity
-        ],
-        platform: platformNode?.attrs?.name
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
     }
+    
     return {
         creds: authUpdate,
         reply
@@ -219,7 +249,7 @@ const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
     if (!includeSignatureKey || !account.accountSignatureKey?.length) {
         account.accountSignatureKey = null
     }
-    return WAProto_1.proto.ADVSignedDeviceIdentity.encode(account).finish()
+    return proto.ADVSignedDeviceIdentity.encode(account).finish()
 }
 
 module.exports = {