@neelegirl/baileys 1.5.5 → 1.5.7

package/lib/Utils/signal.d.ts

@@ -0,0 +1,42 @@
+import { SignalRepository } from '../Types'
+import { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth'
+import { BinaryNode, JidWithDevice } from '../WABinary'
+import { USyncQueryResultList } from '../WAUSync'
+
+export declare const createSignalIdentity: (wid: string, accountSignatureKey: Uint8Array) => SignalIdentity
+
+export declare const getPreKeys: ({ get }: SignalKeyStore, min: number, limit: number) => Promise<{
+    [id: string]: KeyPair
+}>
+
+export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: number) => {
+    newPreKeys: {
+        [id: number]: KeyPair
+    }
+    lastPreKeyId: number
+    preKeysRange: readonly [number, number]
+}
+
+export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode
+
+export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode
+
+export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepository) => Promise<void>
+
+export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, excludeZeroDevices: boolean) => JidWithDevice[]
+
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+export declare const getNextPreKeys: ({ creds, keys }: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>
+    preKeys: {
+        [id: string]: KeyPair
+    }
+}>
+
+export declare const getNextPreKeysNode: (state: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>
+    node: BinaryNode
+}>

package/lib/Utils/signal.js

@@ -0,0 +1,166 @@
+"use strict"
+
+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 createSignalIdentity = (wid, accountSignatureKey) => {
+    return {
+        identifier: { name: wid, deviceId: 0 },
+        identifierKey: crypto_1.generateSignalPubKey(accountSignatureKey)
+    }
+}
+
+const getPreKeys = async ({ get }, min, limit) => {
+    const idList = []
+    for (let id = min; id < limit; id++) {
+        idList.push(id.toString())
+    }
+    return get('pre-key', idList)
+}
+
+const generateOrGetPreKeys = (creds, range) => {
+    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
+    const remaining = range - avaliable
+    const lastPreKeyId = creds.nextPreKeyId + remaining - 1
+    const newPreKeys = {}
+    if (remaining > 0) {
+        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
+            newPreKeys[i] = crypto_1.Curve.generateKeyPair()
+        }
+    }
+    return {
+        newPreKeys,
+        lastPreKeyId,
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range],
+    }
+}
+
+const xmppSignedPreKey = (key) => ({
+    tag: 'skey',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(key.keyId, 3) },
+        { tag: 'value', attrs: {}, content: key.keyPair.public },
+        { tag: 'signature', attrs: {}, content: key.signature }
+    ]
+})
+
+const xmppPreKey = (pair, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: generics_1.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')
+    for (const node of nodes) {
+        WABinary_1.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)
+    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')
+            const jid = node.attrs.jid
+            const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
+            await repository.injectE2ESession({
+                jid,
+                session: {
+                    registrationId: registrationId,
+                    identityKey: crypto_1.generateSignalPubKey(identity),
+                    signedPreKey: extractKey(signedKey),
+                    preKey: extractKey(key)
+                }
+            })
+        }))
+    }
+}
+
+const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
+    const extracted = []
+    for (const userResult of result) {
+        const { devices, id } = userResult
+        const { user } = WABinary_1.jidDecode(id)
+        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 })
+                }
+            }
+        }
+    }
+    return extracted
+}
+
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count)
+    const update = {
+        nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+        firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
+    }
+    await keys.set({ 'pre-key': newPreKeys })
+    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
+    return { update, preKeys }
+}
+
+const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state
+    const { update, preKeys } = await getNextPreKeys(state, count)
+    const node = {
+        tag: 'iq',
+        attrs: {
+            xmlns: 'encrypt',
+            type: 'set',
+            to: WABinary_1.S_WHATSAPP_NET,
+        },
+        content: [
+            { tag: 'registration', attrs: {}, content: generics_1.encodeBigEndian(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: Defaults_1.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)
+        ]
+    }
+    return { update, node }
+}
+
+module.exports = {
+  createSignalIdentity, 
+  getPreKeys, 
+  generateOrGetPreKeys, 
+  xmppSignedPreKey, 
+  xmppPreKey, 
+  parseAndInjectE2ESessions, 
+  extractDeviceJids, 
+  getNextPreKeys, 
+  getNextPreKeysNode
+}

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

@@ -0,0 +1,6 @@
+import { AuthenticationState } from '../Types'
+
+export declare const useMongoFileAuthState: (collection: string) => Promise<{
+    state: AuthenticationState
+    saveCreds: () => Promise<void>
+}>

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

@@ -0,0 +1,84 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const WAProto_1 = require("../../WAProto")
+const auth_utils_1 = require("./auth-utils")
+const generics_1 = require("./generics")
+
+/*
+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_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_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')) || auth_utils_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 = WAProto_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")
+    }
+  }
+}
+
+module.exports = {
+  useMongoFileAuthState
+}

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

@@ -0,0 +1,18 @@
+import { AuthenticationState } from '../Types'
+
+/**
+ * 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>
+}>
+
+export declare const useMultiFileAuthStateV2: (folder: string) => Promise<{
+    state: AuthenticationState
+    saveCreds: () => Promise<void>
+}>

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

@@ -0,0 +1,238 @@
+"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")
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
+const fileLocks = new Map()
+
+// Get or create a mutex for a specific file path
+const getFileLock = (path) => {
+	let mutex = fileLocks.get(path)
+	if (!mutex) {
+		mutex = new async_mutex_1.Mutex() 
+		fileLocks.set(path, mutex)
+	}
+
+	return mutex
+}
+
+/**
+ * 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
+ * */
+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 mutex = getFileLock(filePath)
+        return mutex.acquire().then(async (release) => {
+            try {
+               await promises_1.writeFile(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer))
+            } finally {
+                release()
+            }
+        })
+    }
+    const readData = async (file) => {
+        try {
+            const filePath = path_1.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' })
+                } finally {
+                    release()
+                }
+            })
+
+            return JSON.parse(data, generics_1.BufferJSON.reviver)
+        } catch (error) {
+            return null
+        }
+    }
+    const removeData = async (file) => {
+        try {
+            const filePath = path_1.join(folder, fixFileName(file))
+            const mutex = getFileLock(filePath)
+            await mutex.acquire().then(async (release) => {
+               try {
+                    await promises_1.unlink(filePath)
+                } finally {
+                    release()
+                }
+            })
+        } catch {}
+    }
+    const folderInfo = await promises_1.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 })
+    }
+    const fixFileName = (file) => { 
+        return file?.replace(/\//g, '__')?.replace(/:/g, '-') 
+    }
+    const creds = await readData('creds.json') || auth_utils_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}.json`)
+                        if (type === 'app-state-sync-key' && value) {
+                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value)
+                        }
+                        data[id] = value
+                    }))
+                    return data
+                },
+                set: async (data) => {
+                    const tasks = []
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id]
+                            const file = `${category}-${id}.json`
+                            tasks.push(value ? writeData(value, file) : removeData(file))
+                        }
+                    }
+                    await Promise.all(tasks)
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json')
+        }
+    }
+}
+
+/**
+ * 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
+ * */
+const useMultiFileAuthStateV2 = async (folder) => {
+    const fixFileName = (file) => {
+        return file?.replace(/\//g, '__')?.replace(/:/g, '-')
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const writeData = async (data, file) => {
+        const filePath = path_1.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, 2) // <-- lesbar formatiert
+                )
+            } finally {
+                release()
+            }
+        })
+    }
+
+    const readData = async (file) => {
+        try {
+            const filePath = path_1.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' })
+                } finally {
+                    release()
+                }
+            })
+
+            return JSON.parse(data, generics_1.BufferJSON.reviver)
+        } catch (error) {
+            return null
+        }
+    }
+
+    const removeData = async (file) => {
+        try {
+            const filePath = path_1.join(folder, fixFileName(file))
+            const mutex = getFileLock(filePath)
+            await mutex.acquire().then(async (release) => {
+                try {
+                    await promises_1.unlink(filePath)
+                } finally {
+                    release()
+                }
+            })
+        } catch {}
+    }
+
+    const folderInfo = await promises_1.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 })
+    }
+
+    const creds = await readData('creds.json') || auth_utils_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}.json`)
+                        if (type === 'app-state-sync-key' && value) {
+                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value)
+                        }
+                        data[id] = value
+                    }))
+                    return data
+                },
+                set: async (data) => {
+                    const tasks = []
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id]
+                            const file = `${category}-${id}.json`
+                            tasks.push(value ? writeData(value, file) : removeData(file))
+                        }
+                    }
+                    await Promise.all(tasks)
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json')
+        }
+    }
+}
+
+
+module.exports = {
+  useMultiFileAuthState,
+  useMultiFileAuthStateV2
+}

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

@@ -0,0 +1,13 @@
+import { ILogger } from './logger'
+import type { AuthenticationState } from '../Types'
+
+/**
+ * @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
+ * */
+export declare const useSingleFileAuthState: (filename: string, logger?: ILogger) => {
+    state: AuthenticationState
+    saveState: () => void
+}

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

@@ -0,0 +1,80 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const WAProto_1 = require("../../WAProto")
+const auth_utils_1 = require("./auth-utils")
+const generics_1 = require("./generics")
+
+// 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) => {
+    // require fs here so that in case "fs" is not available -- the app does not crash
+    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_1.BufferJSON.replacer, 2))
+    }
+    if (existsSync(filename)) {
+        const result = JSON.parse(readFileSync(filename, { encoding: 'utf-8' }), generics_1.BufferJSON.reviver)
+        creds = result.creds
+        keys = result.keys
+    }
+    else {
+        creds = auth_utils_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 = WAProto_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
+    }
+}
+
+module.exports = {
+  useSingleFileAuthState
+}

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

@@ -0,0 +1,13 @@
+import { proto } from '../../WAProto'
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types'
+import { BinaryNode } from '../WABinary'
+
+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