@neelegirl/baileys 2.1.8 → 2.2.0

package/lib/Defaults/baileys-version.json

@@ -1 +1 @@
-{"version":[2,3000,1035194821]}
+{"version":[2,3000,1032141294]}

package/lib/Defaults/index.d.ts

@@ -1,28 +1,19 @@
-import { proto } from '../../WAProto'
+import { proto } from '../../WAProto'
 import type { MediaType, SocketConfig } from '../Types'
 
 export declare const UNAUTHORIZED_CODES: number[]
 
 export declare const PHONENUMBER_MCC: Record<string, number>
 
-export declare const DEFAULT_ORIGIN: 'https://web.whatsapp.com'
+export declare const DEFAULT_ORIGIN: "https://web.whatsapp.com"
 
-export declare const CALL_VIDEO_PREFIX: 'https://call.whatsapp.com/video/'
-export declare const CALL_AUDIO_PREFIX: 'https://call.whatsapp.com/voice/'
-
-export declare const DEF_CALLBACK_PREFIX: 'CB:'
-export declare const DEF_TAG_PREFIX: 'TAG:'
-export declare const PHONE_CONNECTION_CB: 'CB:Pong'
-
-export declare const WA_ADV_ACCOUNT_SIG_PREFIX: Buffer
-export declare const WA_ADV_DEVICE_SIG_PREFIX: Buffer
-export declare const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX: Buffer
-export declare const WA_ADV_HOSTED_DEVICE_SIG_PREFIX: Buffer
+export declare const DEF_CALLBACK_PREFIX: "CB:"
+export declare const DEF_TAG_PREFIX: "TAG:"
+export declare const PHONE_CONNECTION_CB: "CB:Pong"
 
 export declare const WA_DEFAULT_EPHEMERAL: number
-export declare const STATUS_EXPIRY_SECONDS: number
 
-export declare const NOISE_MODE: 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0'
+export declare const NOISE_MODE: "Noise_XX_25519_AESGCM_SHA256\0\0\0\0"
 
 export declare const DICT_VERSION: 3
 
@@ -33,8 +24,6 @@ export declare const URL_REGEX: RegExp
 
 export declare const WA_CERT_DETAILS: {
     SERIAL: number
-    ISSUER: string
-    PUBLIC_KEY: Buffer
 }
 
 export declare const PROCESSABLE_HISTORY_TYPES: proto.Message.HistorySyncNotification.HistorySyncType[]
@@ -46,16 +35,15 @@ export declare const MEDIA_PATH_MAP: {
 }
 
 export declare const MEDIA_HKDF_KEY_MAPPING: {
-    audio: string
-    document: string
-    gif: string
-    image: string
-    ppic: string
-    product: string
-    ptt: string
-    video: string
-    sticker: string
-    'sticker-pack': string
+    'audio': string
+    'document': string
+    'gif': string
+    'image': string
+    'ppic': string
+    'product': string
+    'ptt': string
+    'sticker': string
+    'video': string
     'thumbnail-document': string
     'thumbnail-image': string
     'thumbnail-video': string
@@ -64,18 +52,17 @@ export declare const MEDIA_HKDF_KEY_MAPPING: {
     'md-app-state': string
     'product-catalog-image': string
     'payment-bg-image': string
-    ptv: string
-    'biz-cover-photo': string
+    'ptv': string
 }
 
 export declare const MEDIA_KEYS: (keyof typeof MEDIA_HKDF_KEY_MAPPING)[]
 
 export declare const MIN_PREKEY_COUNT: 5
-export declare const INITIAL_PREKEY_COUNT: 812
+export declare const INITIAL_PREKEY_COUNT: 30
 
 export declare const DEFAULT_CACHE_TTLS: {
     SIGNAL_STORE: number
     MSG_RETRY: number
     CALL_OFFER: number
     USER_DEVICES: number
-}
+}

package/lib/Signal/libsignal.d.ts

@@ -1,9 +1,4 @@
-import { LIDMapping, SignalAuthState } from '../Types'
-import { SignalRepositoryWithLIDStore } from '../Types/Signal'
-import type { ILogger } from '../Utils/logger'
+import { SignalAuthState } from '../Types'
+import { SignalRepository } from '../Types/Signal'
 
-export declare function makeLibSignalRepository(
-    auth: SignalAuthState,
-    logger: ILogger,
-    pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>
-): SignalRepositoryWithLIDStore
+export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository

package/lib/Signal/libsignal.js

@@ -1,332 +1,123 @@
 "use strict"
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    var desc = Object.getOwnPropertyDescriptor(m, k)
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k] } }
+    }
+    Object.defineProperty(o, k2, desc)
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    o[k2] = m[k]
+}))
+
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v })
+}) : function(o, v) {
+    o["default"] = v
+})
+
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod
+    var result = {}
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
+    __setModuleDefault(result, mod)
+    return result
+}
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const libsignal = require("@neelegirl/libsignal")
-const { PreKeyWhisperMessage } = require("@neelegirl/libsignal/src/protobufs")
-const LRUCacheModule = require("lru-cache")
-const LRUCache = LRUCacheModule.LRUCache || LRUCacheModule
+const libsignal = __importStar(require("@neelegirl/libsignal"))
 const WASignalGroup_1 = require("./WASignalGroup")
-const lid_mapping_1 = require("./lid-mapping")
 const Utils_1 = require("../Utils")
 const WABinary_1 = require("../WABinary")
 
-function extractIdentityFromPkmsg(ciphertext) {
-    try {
-        if (!ciphertext || ciphertext.length < 2) {
-            return undefined
-        }
-        const version = ciphertext[0]
-        if ((version & 0xf) !== 3) {
-            return undefined
-        }
-        const preKeyProto = PreKeyWhisperMessage.decode(ciphertext.slice(1))
-        if (preKeyProto.identityKey?.length === 33) {
-            return new Uint8Array(preKeyProto.identityKey)
-        }
-    }
-    catch (_error) { }
-}
-
-function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
-    const parsedKeys = auth.keys
-    const lidMapping = new lid_mapping_1.LIDMappingStore(parsedKeys, logger, pnToLIDFunc)
-    const storage = signalStorage(auth, lidMapping)
-    const migratedSessionCache = new LRUCache({
-        ttl: 3 * 24 * 60 * 60 * 1000,
-        ttlAutopurge: true,
-        updateAgeOnGet: true
-    })
-    const repository = {
+function makeLibSignalRepository(auth) {
+    const storage = signalStorage(auth)
+    return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid)
             const cipher = new WASignalGroup_1.GroupCipher(storage, senderName)
-            return parsedKeys.transaction(async () => {
-                return cipher.decrypt(msg)
-            }, group)
+            return cipher.decrypt(msg)
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
-            if (!item.groupId) {
-                throw new Error('group ID is required for sender key distribution message')
-            }
             const builder = new WASignalGroup_1.GroupSessionBuilder(storage)
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid)
-            const senderNameStr = senderName.toString()
-            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(
-                null,
-                null,
-                null,
-                null,
-                item.axolotlSenderKeyDistributionMessage
-            )
-            return parsedKeys.transaction(async () => {
-                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
-                if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
-                }
-                await builder.process(senderName, senderMsg)
-            }, item.groupId)
+            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
+            }
+            await builder.process(senderName, senderMsg)
         },
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid)
             const session = new libsignal.SessionCipher(storage, addr)
-            if (type === 'pkmsg') {
-                const identityKey = extractIdentityFromPkmsg(ciphertext)
-                if (identityKey) {
-                    const addrStr = addr.toString()
-                    const identityChanged = await storage.saveIdentity(addrStr, identityKey)
-                    if (identityChanged) {
-                        logger?.info?.({ jid, addr: addrStr }, 'identity key changed or contact was first seen')
-                    }
-                }
+            let result
+            switch (type) {
+                case 'pkmsg':
+                    result = await session.decryptPreKeyWhisperMessage(ciphertext)
+                    break
+                case 'msg':
+                    result = await session.decryptWhisperMessage(ciphertext)
+                    break
             }
-            return parsedKeys.transaction(async () => {
-                switch (type) {
-                    case 'pkmsg':
-                        return session.decryptPreKeyWhisperMessage(ciphertext)
-                    case 'msg':
-                    default:
-                        return session.decryptWhisperMessage(ciphertext)
-                }
-            }, jid)
+            return result
         },
         async encryptMessage({ jid, data }) {
             const addr = jidToSignalProtocolAddress(jid)
             const cipher = new libsignal.SessionCipher(storage, addr)
-            return parsedKeys.transaction(async () => {
-                const { type: sigType, body } = await cipher.encrypt(data)
-                const type = sigType === 3 ? 'pkmsg' : 'msg'
-                return {
-                    type,
-                    ciphertext: Buffer.from(body, 'binary')
-                }
-            }, jid)
+            const { type: sigType, body } = await cipher.encrypt(data)
+            const type = sigType === 3 ? 'pkmsg' : 'msg'
+            return { type, ciphertext: Buffer.from(body, 'binary') }
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId)
             const builder = new WASignalGroup_1.GroupSessionBuilder(storage)
-            return parsedKeys.transaction(async () => {
-                const senderKeyDistributionMessage = await builder.create(senderName)
-                const session = new WASignalGroup_1.GroupCipher(storage, senderName)
-                const ciphertext = await session.encrypt(data)
-                return {
-                    ciphertext,
-                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
-                }
-            }, group)
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName)
+            const session = new WASignalGroup_1.GroupCipher(storage, senderName)
+            const ciphertext = await session.encrypt(data)
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+            }
         },
         async injectE2ESession({ jid, session }) {
-            logger?.trace?.({ jid }, 'injecting E2EE session')
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid))
-            return parsedKeys.transaction(async () => {
-                await cipher.initOutgoing(session)
-            }, jid)
+            await cipher.initOutgoing(session)
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString()
         },
-        lidMapping,
-        async validateSession(jid) {
-            try {
-                const addr = jidToSignalProtocolAddress(jid)
-                const session = await storage.loadSession(addr.toString())
-                if (!session) {
-                    return { exists: false, reason: 'no session' }
-                }
-                if (!session.haveOpenSession()) {
-                    return { exists: false, reason: 'no open session' }
-                }
-                return { exists: true }
-            }
-            catch (_error) {
-                return { exists: false, reason: 'validation error' }
-            }
-        },
-        async deleteSession(jids) {
-            if (!jids?.length) {
-                return
-            }
-            const sessionUpdates = {}
-            for (const jid of jids) {
-                const addr = jidToSignalProtocolAddress(jid)
-                sessionUpdates[addr.toString()] = null
-            }
-            await parsedKeys.transaction(async () => {
-                await auth.keys.set({ session: sessionUpdates })
-            }, `delete-${jids.length}-sessions`)
-        },
-        async migrateSession(fromJid, toJid) {
-            if (!fromJid || (!(0, WABinary_1.isLidUser)(toJid) && !(0, WABinary_1.isHostedLidUser)(toJid))) {
-                return { migrated: 0, skipped: 0, total: 0 }
-            }
-            if (!(0, WABinary_1.isPnUser)(fromJid) && !(0, WABinary_1.isHostedPnUser)(fromJid)) {
-                return { migrated: 0, skipped: 0, total: 1 }
-            }
-            const fromDecoded = (0, WABinary_1.jidDecode)(fromJid)
-            const user = fromDecoded?.user
-            if (!user) {
-                return { migrated: 0, skipped: 0, total: 0 }
-            }
-            const { [user]: userDevices } = await parsedKeys.get('device-list', [user])
-            if (!userDevices?.length) {
-                return { migrated: 0, skipped: 0, total: 0 }
-            }
-            const fromDeviceStr = (fromDecoded?.device || 0).toString()
-            if (!userDevices.includes(fromDeviceStr)) {
-                userDevices.push(fromDeviceStr)
-            }
-            const uncachedDevices = userDevices.filter(device => !migratedSessionCache.has(`${user}.${device}`))
-            const deviceSessionKeys = uncachedDevices.map(device => `${user}.${device}`)
-            const existingSessions = deviceSessionKeys.length
-                ? await parsedKeys.get('session', deviceSessionKeys)
-                : {}
-            const deviceJids = []
-            for (const [sessionKey, sessionData] of Object.entries(existingSessions)) {
-                if (!sessionData) {
-                    continue
-                }
-                const deviceStr = sessionKey.split('.')[1]
-                if (!deviceStr) {
-                    continue
-                }
-                const deviceNum = parseInt(deviceStr, 10)
-                let jid = `${user}${deviceNum ? `:${deviceNum}` : ''}@s.whatsapp.net`
-                if (deviceNum === 99) {
-                    jid = `${user}:99@hosted`
-                }
-                deviceJids.push(jid)
-            }
-            return parsedKeys.transaction(async () => {
-                const migrationOps = deviceJids.map(jid => {
-                    const lidWithDevice = (0, WABinary_1.transferDevice)(jid, toJid)
-                    const fromDecoded = (0, WABinary_1.jidDecode)(jid)
-                    return {
-                        fromJid: jid,
-                        toJid: lidWithDevice,
-                        pnUser: fromDecoded?.user,
-                        deviceId: fromDecoded?.device || 0,
-                        fromAddr: jidToSignalProtocolAddress(jid),
-                        toAddr: jidToSignalProtocolAddress(lidWithDevice)
-                    }
-                })
-                const totalOps = migrationOps.length
-                let migratedCount = 0
-                const pnAddrStrings = [...new Set(migrationOps.map(op => op.fromAddr.toString()))]
-                const pnSessions = pnAddrStrings.length
-                    ? await parsedKeys.get('session', pnAddrStrings)
-                    : {}
-                const sessionUpdates = {}
-                for (const op of migrationOps) {
-                    const pnAddrStr = op.fromAddr.toString()
-                    const lidAddrStr = op.toAddr.toString()
-                    const pnSession = pnSessions[pnAddrStr]
-                    if (!pnSession) {
-                        continue
-                    }
-                    const fromSession = libsignal.SessionRecord.deserialize(pnSession)
-                    if (!fromSession.haveOpenSession()) {
-                        continue
-                    }
-                    sessionUpdates[lidAddrStr] = fromSession.serialize()
-                    sessionUpdates[pnAddrStr] = null
-                    migratedCount += 1
-                }
-                if (Object.keys(sessionUpdates).length) {
-                    await parsedKeys.set({ session: sessionUpdates })
-                    for (const op of migrationOps) {
-                        if (sessionUpdates[op.toAddr.toString()] && op.pnUser) {
-                            migratedSessionCache.set(`${op.pnUser}.${op.deviceId}`, true)
-                        }
-                    }
-                }
-                return {
-                    migrated: migratedCount,
-                    skipped: totalOps - migratedCount,
-                    total: totalOps
-                }
-            }, `migrate-${deviceJids.length}-sessions-${(0, WABinary_1.jidDecode)(toJid)?.user || 'unknown'}`)
-        }
     }
-    return repository
 }
 
 const jidToSignalProtocolAddress = (jid) => {
-    const decoded = (0, WABinary_1.jidDecode)(jid)
-    const { user, device, server, domainType } = decoded || {}
-    if (!user) {
-        throw new Error(`JID decoded but user is empty: ${jid}`)
-    }
-    const signalUser = domainType !== WABinary_1.WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user
-    const finalDevice = device || 0
-    if (device === 99 && server !== 'hosted' && server !== 'hosted.lid') {
-        throw new Error(`unexpected non-hosted device 99 JID: ${jid}`)
-    }
-    return new libsignal.ProtocolAddress(signalUser, finalDevice)
+    const { user, device } = WABinary_1.jidDecode(jid)
+    return new libsignal.ProtocolAddress(user, device || 0)
 }
 
 const jidToSignalSenderKeyName = (group, user) => {
-    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user))
+    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString()
 }
 
-function signalStorage({ creds, keys }, lidMapping) {
-    const resolveLIDSignalAddress = async (id) => {
-        if (id.includes('.')) {
-            const [deviceId, device] = id.split('.')
-            const [user, domainType_] = deviceId.split('_')
-            const domainType = parseInt(domainType_ || '0', 10)
-            if (domainType === WABinary_1.WAJIDDomains.LID || domainType === WABinary_1.WAJIDDomains.HOSTED_LID) {
-                return id
-            }
-            const pnJid = `${user}${device !== '0' ? `:${device}` : ''}@${domainType === WABinary_1.WAJIDDomains.HOSTED ? 'hosted' : 's.whatsapp.net'}`
-            const lidForPN = await lidMapping.getLIDForPN(pnJid)
-            if (lidForPN) {
-                return jidToSignalProtocolAddress(lidForPN).toString()
-            }
-        }
-        return id
-    }
+function signalStorage({ creds, keys }) {
     return {
         loadSession: async (id) => {
-            try {
-                const wireJid = await resolveLIDSignalAddress(id)
-                const { [wireJid]: sess } = await keys.get('session', [wireJid])
-                if (sess) {
-                    return libsignal.SessionRecord.deserialize(sess)
-                }
+            const { [id]: sess } = await keys.get('session', [id])
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess)
             }
-            catch (_error) {
-                return null
-            }
-            return null
         },
         storeSession: async (id, session) => {
-            const wireJid = await resolveLIDSignalAddress(id)
-            await keys.set({ session: { [wireJid]: session.serialize() } })
-        },
-        isTrustedIdentity: () => true,
-        loadIdentityKey: async (id) => {
-            const wireJid = await resolveLIDSignalAddress(id)
-            const { [wireJid]: key } = await keys.get('identity-key', [wireJid])
-            return key || undefined
+            await keys.set({ 'session': { [id]: session.serialize() } })
         },
-        saveIdentity: async (id, identityKey) => {
-            const wireJid = await resolveLIDSignalAddress(id)
-            const { [wireJid]: existingKey } = await keys.get('identity-key', [wireJid])
-            const keysMatch = existingKey
-                && existingKey.length === identityKey.length
-                && existingKey.every((byte, i) => byte === identityKey[i])
-            if (existingKey && !keysMatch) {
-                await keys.set({
-                    session: { [wireJid]: null },
-                    'identity-key': { [wireJid]: identityKey }
-                })
-                return true
-            }
-            if (!existingKey) {
-                await keys.set({ 'identity-key': { [wireJid]: identityKey } })
-                return true
-            }
-            return false
+        isTrustedIdentity: () => {
+            return true
         },
         loadPreKey: async (id) => {
             const keyId = id.toString()
@@ -346,26 +137,26 @@ function signalStorage({ creds, keys }, lidMapping) {
                 pubKey: Buffer.from(key.keyPair.public)
             }
         },
-        loadSenderKey: async (senderKeyName) => {
-            const keyId = senderKeyName.toString()
+        loadSenderKey: async (keyId) => {
             const { [keyId]: key } = await keys.get('sender-key', [keyId])
-            return key ? new WASignalGroup_1.SenderKeyRecord(key) : new WASignalGroup_1.SenderKeyRecord()
+            if (key) {
+                return new WASignalGroup_1.SenderKeyRecord(key)
+            }
         },
-        storeSenderKey: async (senderKeyName, key) => {
-            const keyId = senderKeyName.toString()
+        storeSenderKey: async (keyId, key) => {
             await keys.set({ 'sender-key': { [keyId]: key.serialize() } })
         },
-        getOurRegistrationId: () => creds.registrationId,
+        getOurRegistrationId: () => (creds.registrationId),
         getOurIdentity: () => {
             const { signedIdentityKey } = creds
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: Buffer.from((0, Utils_1.generateSignalPubKey)(signedIdentityKey.public))
+                pubKey: Utils_1.generateSignalPubKey(signedIdentityKey.public),
             }
         }
     }
 }
 
 module.exports = {
-    makeLibSignalRepository
-}
+  makeLibSignalRepository
+}

package/lib/Socket/chats.js

@@ -21,7 +21,7 @@ const MAX_SYNC_ATTEMPTS = 2
 const makeChatsSocket = (config) => {
     const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, } = config
     const Neele = usync_1.makeUSyncSocket(config)
-    const { ev, ws, authState, generateMessageTag, sendNode, query, onUnexpectedError, groupFetchAllParticipating, signalRepository } = Neele
+    const { ev, ws, authState, generateMessageTag, sendNode, query, onUnexpectedError, groupFetchAllParticipating } = Neele
     
     let privacySettings
     let syncState = Types_1.SyncState.Connecting
@@ -1000,7 +1000,6 @@ const makeChatsSocket = (config) => {
                 logger,
                 options: config.options,
                 getMessage: config.getMessage,
-                signalRepository,
             })
         ])
         
@@ -1131,4 +1130,4 @@ const makeChatsSocket = (config) => {
 
 module.exports = {
   makeChatsSocket
-}
+}

package/lib/Socket/socket.js

@@ -793,7 +793,7 @@ const makeSocket = (config) => {
                 try {
                     const myPN = authState.creds.me.id
                     // Store our own LID-PN mapping
-                    await signalRepository.lidMapping.storeLIDPNMappings([{ lid: myLID, pn: myPN }])
+                    await signalRepository?.lidMapping?.storeLIDPNMappings?.([{ lid: myLID, pn: myPN }])
                     // Create device list for our own user (needed for bulk migration)
                     const { user, device } = WABinary_1.jidDecode(myPN)
                     await authState.keys.set({
@@ -802,7 +802,7 @@ const makeSocket = (config) => {
                         }
                     })
                     // migrate our own session
-                    await signalRepository.migrateSession(myPN, myLID)
+                    await signalRepository?.migrateSession?.(myPN, myLID)
                     logger.info({ myPN, myLID }, 'Own LID session created successfully')
                 }
                 catch (error) {
@@ -944,4 +944,4 @@ function mapWebSocketError(handler) {
 
 module.exports = {
   makeSocket
-}
+}

package/lib/Types/Auth.d.ts

@@ -24,11 +24,6 @@ export type SignalIdentity = {
     identifierKey: Uint8Array
 }
 
-export type LIDMapping = {
-    pn: string
-    lid: string
-}
-
 export type LTHashState = {
     version: number
     hash: Buffer
@@ -72,7 +67,6 @@ export type AuthenticationCreds = SignalCreds & {
     pairingCode: string | undefined
     lastPropHash: string | undefined
     routingInfo: Buffer | undefined
-    additionalData?: any | undefined
 }
 
 export type SignalDataTypeMap = {
@@ -84,13 +78,6 @@ export type SignalDataTypeMap = {
     }
     'app-state-sync-key': proto.Message.IAppStateSyncKeyData
     'app-state-sync-version': LTHashState
-    'lid-mapping': string
-    'device-list': string[]
-    'tctoken': {
-        token: Buffer
-        timestamp?: string
-    }
-    'identity-key': Uint8Array
 }
 
 export type SignalDataSet = {
@@ -112,7 +99,7 @@ export type SignalKeyStore = {
 
 export type SignalKeyStoreWithTransaction = SignalKeyStore & {
     isInTransaction: () => boolean
-    transaction<T>(exec: () => Promise<T>, key?: string): Promise<T>
+    transaction<T>(exec: () => Promise<T>): Promise<T>
 }
 
 export type TransactionCapabilityOptions = {
@@ -130,4 +117,4 @@ export type AuthenticationState = {
     keys: SignalKeyStore
 }
 
-export {}
+export {}

package/lib/Types/Contact.d.ts

@@ -2,7 +2,6 @@ export interface Contact {
     id: string
     lid?: string
     jid?: string
-    phoneNumber?: string
     /** name of the contact, you have saved on your WA */
     name?: string
     /** name of the contact, the contact has set on their own on WA */
@@ -18,4 +17,4 @@ export interface Contact {
      */
     imgUrl?: string | null
     status?: string
-}
+}