lordceaser-baileys 2.0.11 → 2.0.13

package/lib/Utils/signal.js

@@ -1,166 +0,0 @@
-"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

@@ -1,6 +0,0 @@
-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

@@ -1,84 +0,0 @@
-"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, generic_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

@@ -1,13 +0,0 @@
-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>
-}>

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

@@ -1,131 +0,0 @@
-"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')
-        }
-    }
-}
-
-module.exports = {
-  useMultiFileAuthState
-}

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

@@ -1,13 +0,0 @@
-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

@@ -1,80 +0,0 @@
-"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/use-sql-file-auth-state.d.ts

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

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

@@ -1,143 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const promise_1 = __importDefault(require("mysql2/promise"));
-const Utils_1 = require("../Utils");
-// Create MySQL connection pool for better performance
-/*
-code from amiruldev readjusted by @irull2nd, don't delete WM!
-*/
-const createConnectionPool = (config) => {
-    return promise_1.default.createPool({
-        host: config.host,
-        user: config.user,
-        password: config.password,
-        database: config.database,
-        waitForConnections: true,
-        connectionLimit: 10,
-        queueLimit: 0
-    });
-};
-const useSqlAuthState = async (config) => {
-    const { host, user, password, database, tableName, session } = config;
-    const pool = createConnectionPool({ host, user, password, database });
-    const table = tableName !== null && tableName !== void 0 ? tableName : 'amiruldev_auth';
-    const sessionName = session !== null && session !== void 0 ? session : `session_`;
-    // Create table if it doesn't exist
-    const createTable = async () => {
-        await pool.execute(`
-            CREATE TABLE IF NOT EXISTS \`${table}\` (
-                id VARCHAR(255) PRIMARY KEY,
-                value JSON,
-                session VARCHAR(255),
-                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-            )
-        `);
-    };
-    // Delete sessions older than 1 day
-    const deleteOldSessions = async () => {
-        await pool.execute(`
-            DELETE FROM \`${table}\` 
-            WHERE session = ? AND timestamp < NOW() - INTERVAL 1 DAY
-        `, [sessionName]);
-    };
-    // Remove unused tables (if any)
-    const removeUnusedTables = async () => {
-        const [rows] = await pool.execute(`
-            SELECT table_name 
-            FROM information_schema.tables 
-            WHERE table_schema = ? AND table_name != ?`, [database, table]);
-        const unusedTables = rows.filter((row) => !row.table_name.startsWith('session_'));
-        for (const { table_name } of unusedTables) {
-            await pool.execute(`DROP TABLE IF EXISTS \`${table_name}\``);
-        }
-    };
-    // Ensure creds entry exists
-    const ensureSession = async () => {
-        const [rows] = await pool.execute(`SELECT * FROM \`${table}\` WHERE id = 'creds'`);
-        if (rows.length === 0) {
-            await pool.execute(`INSERT INTO \`${table}\` (id, value, session) VALUES ('creds', ?, ?)`, [JSON.stringify((0, Utils_1.initAuthCreds)(), Utils_1.BufferJSON.replacer), sessionName]);
-        }
-    };
-    // Initialize the database
-    await createTable();
-    await deleteOldSessions();
-    await removeUnusedTables();
-    await ensureSession();
-    const query = async (tableName, docId) => {
-        const [rows] = await pool.execute(`SELECT * FROM \`${tableName}\` WHERE id = ?`, [`${sessionName}-${docId}`]);
-        return rows.length > 0 ? rows[0] : null;
-    };
-    const readData = async (id) => {
-        const data = await query(table, id);
-        if (!data || !data.value) {
-            return null;
-        }
-        const creds = typeof data.value === 'string' ? data.value : JSON.stringify(data.value);
-        return JSON.parse(creds, Utils_1.BufferJSON.reviver);
-    };
-    const writeData = async (id, value) => {
-        const valueFixed = JSON.stringify(value, Utils_1.BufferJSON.replacer);
-        await pool.execute(`INSERT INTO \`${table}\` (id, value, session) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE value = VALUES(value), timestamp = CURRENT_TIMESTAMP`, [`${sessionName}-${id}`, valueFixed, sessionName]);
-    };
-    const removeData = async (id) => {
-        await pool.execute(`DELETE FROM \`${table}\` WHERE id = ?`, [`${sessionName}-${id}`]);
-    };
-    const clearAll = async () => {
-        await pool.execute(`DELETE FROM \`${table}\` WHERE session = ? AND id != 'creds'`, [sessionName]);
-    };
-    const removeAll = async () => {
-        await pool.execute(`DELETE FROM \`${table}\` WHERE session = ?`, [sessionName]);
-    };
-    const creds = (await readData('creds')) || (0, Utils_1.initAuthCreds)();
-    return {
-        state: {
-            creds,
-            keys: {
-                get: async (type, ids) => {
-                    const data = {};
-                    for (const id of ids) {
-                        let value = await readData(`${type}-${id}`);
-                        if (type === 'app-state-sync-key' && value) {
-                            value = (0, Utils_1.fromObject)(value);
-                        }
-                        data[id] = value;
-                    }
-                    return data;
-                },
-                set: async (data) => {
-                    for (const category in data) {
-                        for (const id in data[category]) {
-                            const value = data[category][id];
-                            const name = `${category}-${id}`;
-                            if (value) {
-                                await writeData(name, value);
-                            }
-                            else {
-                                await removeData(name);
-                            }
-                        }
-                    }
-                }
-            }
-        },
-        saveCreds: async () => {
-            await writeData('creds', creds);
-        },
-        clear: async () => {
-            await clearAll();
-        },
-        removeCreds: async () => {
-            await removeAll();
-        },
-        query: async (tableName, docId) => {
-            return await query(tableName, docId);
-        }
-    };
-};
-module.exports = {
-   useSqlAuthState
-}

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

@@ -1,13 +0,0 @@
-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