@neelegirl/baileys 2.1.5 → 2.1.7

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,277 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { LRUCache } = require("lru-cache")
+const WABinary_1 = require("../WABinary")
+
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        })
+        this.inflightLIDLookups = new Map()
+        this.inflightPNLookups = new Map()
+        this.keys = keys
+        this.logger = logger
+        this.pnToLIDFunc = pnToLIDFunc
+    }
+    async storeLIDPNMappings(pairs) {
+        if (!pairs?.length) {
+            return
+        }
+        const validatedPairs = []
+        for (const { lid, pn } of pairs) {
+            const validDirection = ((0, WABinary_1.isLidUser)(lid) || (0, WABinary_1.isHostedLidUser)(lid))
+                && ((0, WABinary_1.isPnUser)(pn) || (0, WABinary_1.isHostedPnUser)(pn))
+            const reverseDirection = ((0, WABinary_1.isPnUser)(lid) || (0, WABinary_1.isHostedPnUser)(lid))
+                && ((0, WABinary_1.isLidUser)(pn) || (0, WABinary_1.isHostedLidUser)(pn))
+            if (!validDirection && !reverseDirection) {
+                this.logger?.warn?.({ lid, pn }, 'invalid LID-PN mapping')
+                continue
+            }
+            const lidJid = validDirection ? lid : pn
+            const pnJid = validDirection ? pn : lid
+            const lidDecoded = (0, WABinary_1.jidDecode)(lidJid)
+            const pnDecoded = (0, WABinary_1.jidDecode)(pnJid)
+            if (!lidDecoded?.user || !pnDecoded?.user) {
+                continue
+            }
+            validatedPairs.push({
+                pnUser: pnDecoded.user,
+                lidUser: lidDecoded.user
+            })
+        }
+        if (!validatedPairs.length) {
+            return
+        }
+        const cacheMissSet = new Set()
+        const existingMappings = new Map()
+        for (const { pnUser } of validatedPairs) {
+            const cached = this.mappingCache.get(`pn:${pnUser}`)
+            if (cached) {
+                existingMappings.set(pnUser, cached)
+            }
+            else {
+                cacheMissSet.add(pnUser)
+            }
+        }
+        if (cacheMissSet.size) {
+            const cacheMisses = [...cacheMissSet]
+            this.logger?.trace?.({ count: cacheMisses.length }, 'loading LID mappings from store')
+            const stored = await this.keys.get('lid-mapping', cacheMisses)
+            for (const pnUser of cacheMisses) {
+                const existingLidUser = stored[pnUser]
+                if (existingLidUser) {
+                    existingMappings.set(pnUser, existingLidUser)
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser)
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser)
+                }
+            }
+        }
+        const pairMap = {}
+        for (const { pnUser, lidUser } of validatedPairs) {
+            const existingLidUser = existingMappings.get(pnUser)
+            if (existingLidUser === lidUser) {
+                continue
+            }
+            pairMap[pnUser] = lidUser
+        }
+        if (!Object.keys(pairMap).length) {
+            return
+        }
+        const batchData = {}
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            batchData[pnUser] = lidUser
+            batchData[`${lidUser}_reverse`] = pnUser
+        }
+        await this.keys.transaction(async () => {
+            await this.keys.set({ 'lid-mapping': batchData })
+        }, 'lid-mapping')
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            this.mappingCache.set(`pn:${pnUser}`, lidUser)
+            this.mappingCache.set(`lid:${lidUser}`, pnUser)
+        }
+    }
+    async getLIDForPN(pn) {
+        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null
+    }
+    async getLIDsForPNs(pns) {
+        if (!pns?.length) {
+            return null
+        }
+        const sortedPns = [...new Set(pns)].sort()
+        const cacheKey = sortedPns.join(',')
+        const inflight = this.inflightLIDLookups.get(cacheKey)
+        if (inflight) {
+            return inflight
+        }
+        const promise = this._getLIDsForPNsImpl(pns)
+        this.inflightLIDLookups.set(cacheKey, promise)
+        try {
+            return await promise
+        }
+        finally {
+            this.inflightLIDLookups.delete(cacheKey)
+        }
+    }
+    async _getLIDsForPNsImpl(pns) {
+        const usyncFetch = {}
+        const successfulPairs = {}
+        const pending = []
+        const addResolvedPair = (pn, decoded, lidUser) => {
+            if (!decoded || !lidUser) {
+                return false
+            }
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0
+            const deviceSpecificLid = `${lidUser}${pnDevice ? `:${pnDevice}` : ''}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn }
+            return true
+        }
+        for (const pn of pns) {
+            if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) {
+                continue
+            }
+            const decoded = (0, WABinary_1.jidDecode)(pn)
+            if (!decoded?.user) {
+                continue
+            }
+            const pnUser = decoded.user
+            const cached = this.mappingCache.get(`pn:${pnUser}`)
+            if (cached && typeof cached === 'string') {
+                addResolvedPair(pn, decoded, cached)
+                continue
+            }
+            pending.push({ pn, pnUser, decoded })
+        }
+        if (pending.length) {
+            const pnUsers = [...new Set(pending.map(item => item.pnUser))]
+            const stored = await this.keys.get('lid-mapping', pnUsers)
+            for (const pnUser of pnUsers) {
+                const lidUser = stored[pnUser]
+                if (lidUser && typeof lidUser === 'string') {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser)
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser)
+                }
+            }
+            for (const { pn, pnUser, decoded } of pending) {
+                const cached = this.mappingCache.get(`pn:${pnUser}`)
+                if (cached && typeof cached === 'string') {
+                    addResolvedPair(pn, decoded, cached)
+                    continue
+                }
+                const device = decoded.device || 0
+                let normalizedPn = (0, WABinary_1.jidNormalizedUser)(pn)
+                if ((0, WABinary_1.isHostedPnUser)(normalizedPn)) {
+                    normalizedPn = `${pnUser}@s.whatsapp.net`
+                }
+                if (!usyncFetch[normalizedPn]) {
+                    usyncFetch[normalizedPn] = [device]
+                }
+                else {
+                    usyncFetch[normalizedPn].push(device)
+                }
+            }
+        }
+        if (Object.keys(usyncFetch).length) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch))
+            if (result?.length) {
+                await this.storeLIDPNMappings(result)
+                for (const pair of result) {
+                    const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn)
+                    const lidUser = (0, WABinary_1.jidDecode)(pair.lid)?.user
+                    const pnUser = pnDecoded?.user
+                    if (!pnUser || !lidUser) {
+                        continue
+                    }
+                    for (const device of usyncFetch[pair.pn] || []) {
+                        const deviceSpecificLid = `${lidUser}${device ? `:${device}` : ''}@${device === 99 ? 'hosted.lid' : 'lid'}`
+                        const deviceSpecificPn = `${pnUser}${device ? `:${device}` : ''}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`
+                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn }
+                    }
+                }
+            }
+            else {
+                this.logger?.warn?.('USync did not return LID mappings for pending PN users')
+            }
+        }
+        const values = Object.values(successfulPairs)
+        return values.length ? values : null
+    }
+    async getPNForLID(lid) {
+        return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null
+    }
+    async getPNsForLIDs(lids) {
+        if (!lids?.length) {
+            return null
+        }
+        const sortedLids = [...new Set(lids)].sort()
+        const cacheKey = sortedLids.join(',')
+        const inflight = this.inflightPNLookups.get(cacheKey)
+        if (inflight) {
+            return inflight
+        }
+        const promise = this._getPNsForLIDsImpl(lids)
+        this.inflightPNLookups.set(cacheKey, promise)
+        try {
+            return await promise
+        }
+        finally {
+            this.inflightPNLookups.delete(cacheKey)
+        }
+    }
+    async _getPNsForLIDsImpl(lids) {
+        const successfulPairs = {}
+        const pending = []
+        const addResolvedPair = (lid, decoded, pnUser) => {
+            if (!decoded || !pnUser || typeof pnUser !== 'string') {
+                return false
+            }
+            const lidDevice = decoded.device !== undefined ? decoded.device : 0
+            const pnJid = `${pnUser}${lidDevice ? `:${lidDevice}` : ''}@${decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`
+            successfulPairs[lid] = { lid, pn: pnJid }
+            return true
+        }
+        for (const lid of lids) {
+            if (!(0, WABinary_1.isLidUser)(lid) && !(0, WABinary_1.isHostedLidUser)(lid)) {
+                continue
+            }
+            const decoded = (0, WABinary_1.jidDecode)(lid)
+            if (!decoded?.user) {
+                continue
+            }
+            const lidUser = decoded.user
+            const cached = this.mappingCache.get(`lid:${lidUser}`)
+            if (cached && typeof cached === 'string') {
+                addResolvedPair(lid, decoded, cached)
+                continue
+            }
+            pending.push({ lid, lidUser, decoded })
+        }
+        if (pending.length) {
+            const reverseKeys = [...new Set(pending.map(item => `${item.lidUser}_reverse`))]
+            const stored = await this.keys.get('lid-mapping', reverseKeys)
+            for (const { lid, lidUser, decoded } of pending) {
+                let pnUser = this.mappingCache.get(`lid:${lidUser}`)
+                if (!pnUser || typeof pnUser !== 'string') {
+                    pnUser = stored[`${lidUser}_reverse`]
+                    if (pnUser && typeof pnUser === 'string') {
+                        this.mappingCache.set(`lid:${lidUser}`, pnUser)
+                        this.mappingCache.set(`pn:${pnUser}`, lidUser)
+                    }
+                }
+                if (pnUser && typeof pnUser === 'string') {
+                    addResolvedPair(lid, decoded, pnUser)
+                }
+            }
+        }
+        const values = Object.values(successfulPairs)
+        return values.length ? values : null
+    }
+}
+
+module.exports = {
+    LIDMappingStore
+}

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 } = Neele
+    const { ev, ws, authState, generateMessageTag, sendNode, query, onUnexpectedError, groupFetchAllParticipating, signalRepository } = Neele
     
     let privacySettings
     let syncState = Types_1.SyncState.Connecting
@@ -1000,6 +1000,7 @@ const makeChatsSocket = (config) => {
                 logger,
                 options: config.options,
                 getMessage: config.getMessage,
+                signalRepository,
             })
         ])
         
@@ -1130,4 +1131,4 @@ const makeChatsSocket = (config) => {
 
 module.exports = {
   makeChatsSocket
-}
+}

package/lib/Types/Auth.d.ts

@@ -24,6 +24,11 @@ export type SignalIdentity = {
     identifierKey: Uint8Array
 }
 
+export type LIDMapping = {
+    pn: string
+    lid: string
+}
+
 export type LTHashState = {
     version: number
     hash: Buffer
@@ -67,6 +72,7 @@ export type AuthenticationCreds = SignalCreds & {
     pairingCode: string | undefined
     lastPropHash: string | undefined
     routingInfo: Buffer | undefined
+    additionalData?: any | undefined
 }
 
 export type SignalDataTypeMap = {
@@ -78,6 +84,13 @@ 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 = {
@@ -99,7 +112,7 @@ export type SignalKeyStore = {
 
 export type SignalKeyStoreWithTransaction = SignalKeyStore & {
     isInTransaction: () => boolean
-    transaction<T>(exec: () => Promise<T>): Promise<T>
+    transaction<T>(exec: () => Promise<T>, key?: string): Promise<T>
 }
 
 export type TransactionCapabilityOptions = {
@@ -117,4 +130,4 @@ export type AuthenticationState = {
     keys: SignalKeyStore
 }
 
-export {}
+export {}

package/lib/Types/Contact.d.ts

@@ -2,6 +2,7 @@ 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 */
@@ -17,4 +18,4 @@ export interface Contact {
      */
     imgUrl?: string | null
     status?: string
-}
+}

package/lib/Types/Events.d.ts

@@ -10,6 +10,7 @@ import { LabelAssociation } from './LabelAssociation'
 import { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message'
 import { NewsletterViewRole, SubscriberAction, NewsletterSettingsUpdate } from './Newsletter'
 import { ConnectionState } from './State'
+import { LIDMapping } from './Auth'
 
 export type BaileysEventMap = {
     /** connection state has been updated -- WS closed, opened, connecting etc. */
@@ -21,6 +22,7 @@ export type BaileysEventMap = {
         chats: Chat[]
         contacts: Contact[]
         messages: WAMessage[]
+        lidPnMappings?: LIDMapping[]
         isLatest?: boolean
         progress?: number | null
         syncType?: proto.HistorySync.HistorySyncType
@@ -82,6 +84,7 @@ export type BaileysEventMap = {
     'message-receipt.update': MessageUserReceiptUpdate[]
     'groups.upsert': GroupMetadata[]
     'groups.update': Partial<GroupMetadata>[]
+    'communities.update': Partial<GroupMetadata>[]
     /** apply an action to participants in a group */
     'group-participants.update': {
         id: string
@@ -234,4 +237,4 @@ export interface BaileysEventEmitter {
     off<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void
     removeAllListeners<T extends keyof BaileysEventMap>(event: T): void
     emit<T extends keyof BaileysEventMap>(event: T, arg: BaileysEventMap[T]): boolean
-}
+}

package/lib/Types/Signal.d.ts

@@ -1,4 +1,5 @@
 import { proto } from '../../WAProto'
+import type { LIDMappingStore } from '../Signal/lid-mapping'
 
 type DecryptGroupSignalOpts = {
     group: string
@@ -62,7 +63,21 @@ export type SignalRepository = {
         ciphertext: Uint8Array
     }>
     injectE2ESession(opts: E2ESessionOpts): Promise<void>
+    validateSession(jid: string): Promise<{
+        exists: boolean
+        reason?: string
+    }>
     jidToSignalProtocolAddress(jid: string): string
+    migrateSession(fromJid: string, toJid: string): Promise<{
+        migrated: number
+        skipped: number
+        total: number
+    }>
+    deleteSession(jids: string[]): Promise<void>
+}
+
+export interface SignalRepositoryWithLIDStore extends SignalRepository {
+    lidMapping: LIDMappingStore
 }
 
-export {}
+export {}

package/lib/Types/Socket.d.ts

@@ -3,10 +3,10 @@ import type { Agent } from 'https'
 import { ILogger } from '../Utils/logger'
 import type { URL } from 'url'
 import { proto } from '../../WAProto'
-import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth'
+import { AuthenticationState, LIDMapping, SignalAuthState, TransactionCapabilityOptions } from './Auth'
 import { GroupMetadata } from './GroupMetadata'
 import { MediaConnInfo } from './Message'
-import { SignalRepository } from './Signal'
+import { SignalRepositoryWithLIDStore } from './Signal'
 
 export type WAVersion = [number, number, number]
 
@@ -91,6 +91,8 @@ export type SocketConfig = {
      * entails uploading the jpegThumbnail to WA
      * */
     generateHighQualityLinkPreview: boolean
+    /** Enable automatic session recreation for failed messages */
+    enableAutoSessionRecreation: boolean
     /** Enable recent message caching for retry handling */
     enableRecentMessageCache: boolean
     /**
@@ -118,5 +120,9 @@ export type SocketConfig = {
     getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>
     /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
     cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>
-    makeSignalRepository: (auth: SignalAuthState) => SignalRepository
-}
+    makeSignalRepository: (
+        auth: SignalAuthState,
+        logger: ILogger,
+        pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>
+    ) => SignalRepositoryWithLIDStore
+}

package/lib/Utils/browser-utils.d.ts

@@ -0,0 +1 @@
+export { Browsers, getPlatformId } from './generics'

package/lib/Utils/browser-utils.js

@@ -0,0 +1,10 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const generics_1 = require("./generics")
+
+module.exports = {
+    Browsers: generics_1.Browsers,
+    getPlatformId: generics_1.getPlatformId
+}

package/lib/Utils/history.d.ts

@@ -1,23 +1,30 @@
 import { AxiosRequestConfig } from 'axios'
 import { proto } from '../../WAProto'
-import { Chat, Contact } from '../Types'
+import { Chat, Contact, LIDMapping } from '../Types'
+import { ILogger } from './logger'
 
 export declare const downloadHistory: (msg: proto.Message.IHistorySyncNotification, options: AxiosRequestConfig<{}>) => Promise<proto.HistorySync>
 
-export declare const processHistoryMessage: (item: proto.IHistorySync) => {
+export declare const processHistoryMessage: (item: proto.IHistorySync, logger?: ILogger) => {
     chats: Chat[]
     contacts: Contact[]
     messages: proto.IWebMessageInfo[]
+    lidPnMappings: LIDMapping[]
     syncType: proto.HistorySync.HistorySyncType
     progress: number | null | undefined
 }
 
-export declare const downloadAndProcessHistorySyncNotification: (msg: proto.Message.IHistorySyncNotification, options: AxiosRequestConfig<{}>) => Promise<{
+export declare const downloadAndProcessHistorySyncNotification: (
+    msg: proto.Message.IHistorySyncNotification,
+    options: AxiosRequestConfig<{}>,
+    logger?: ILogger
+) => Promise<{
     chats: Chat[]
     contacts: Contact[]
     messages: proto.IWebMessageInfo[]
+    lidPnMappings: LIDMapping[]
     syncType: proto.HistorySync.HistorySyncType
     progress: number | null | undefined
 }>
 
-export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification | null | undefined
+export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification | null | undefined