@heavstaltech/baileys 1.0.0

package/lib/Utils/signal.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids = exports.parseAndInjectE2ESessions = exports.xmppPreKey = exports.xmppSignedPreKey = exports.generateOrGetPreKeys = exports.getPreKeys = exports.createSignalIdentity = void 0;
+const Defaults_1 = require("../Defaults");
+const WABinary_1 = require("../WABinary");
+const crypto_1 = require("./crypto");
+const generics_1 = require("./generics");
+function chunk(array, size) {
+    const result = [];
+    for (let i = 0; i < array.length; i += size) {
+        result.push(array.slice(i, i + size));
+    }
+    return result;
+}
+const createSignalIdentity = (wid, accountSignatureKey) => {
+    return {
+        identifier: { name: wid, deviceId: 0 },
+        identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
+    };
+};
+exports.createSignalIdentity = createSignalIdentity;
+const getPreKeys = async ({ get }, min, limit) => {
+    const idList = [];
+    for (let id = min; id < limit; id++) {
+        idList.push(id.toString());
+    }
+    return get('pre-key', idList);
+};
+exports.getPreKeys = getPreKeys;
+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],
+    };
+};
+exports.generateOrGetPreKeys = generateOrGetPreKeys;
+const xmppSignedPreKey = (key) => ({
+    tag: 'skey',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
+        { tag: 'value', attrs: {}, content: key.keyPair.public },
+        { tag: 'signature', attrs: {}, content: key.signature }
+    ]
+});
+exports.xmppSignedPreKey = xmppSignedPreKey;
+const xmppPreKey = (pair, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
+        { tag: 'value', attrs: {}, content: pair.public }
+    ]
+});
+exports.xmppPreKey = xmppPreKey;
+const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => (key ? ({
+        keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
+        publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
+        signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature'),
+    }) : undefined);
+    const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user');
+    for (const node of nodes) {
+        (0, 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 = chunk(nodes, chunkSize);
+    for (const nodesChunk of chunks) {
+        await Promise.all(nodesChunk.map(async (node) => {
+            const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
+            const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
+            const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
+            const jid = node.attrs.jid;
+            const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
+            await repository.injectE2ESession({
+                jid,
+                session: {
+                    registrationId: registrationId,
+                    identityKey: (0, crypto_1.generateSignalPubKey)(identity),
+                    signedPreKey: extractKey(signedKey),
+                    preKey: extractKey(key)
+                }
+            });
+        }));
+    }
+};
+exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
+const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
+    const extracted = [];
+    for (const userResult of result) {
+        const { devices, id } = userResult;
+        const { user } = (0, WABinary_1.jidDecode)(id);
+        const deviceList = devices === null || devices === void 0 ? void 0 : 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;
+};
+exports.extractDeviceJids = extractDeviceJids;
+/**
+ * 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 } = (0, exports.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 (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    return { update, preKeys };
+};
+exports.getNextPreKeys = getNextPreKeys;
+const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state;
+    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
+    const node = {
+        tag: 'iq',
+        attrs: {
+            xmlns: 'encrypt',
+            type: 'set',
+            to: WABinary_1.S_WHATSAPP_NET,
+        },
+        content: [
+            { tag: 'registration', attrs: {}, content: (0, 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 => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
+            (0, exports.xmppSignedPreKey)(creds.signedPreKey)
+        ]
+    };
+    return { update, node };
+};
+exports.getNextPreKeysNode = getNextPreKeysNode;

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

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

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMultiFileAuthState = void 0;
+const async_lock_1 = __importDefault(require("async-lock"));
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const WAProto_1 = require("../../WAProto");
+const auth_utils_1 = require("./auth-utils");
+const generics_1 = require("./generics");
+const node_cache_1 = __importDefault(require("node-cache"));
+const Defaults_1 = require("../Defaults");
+
+// Enhanced locking mechanism
+const fileLock = new async_lock_1.default({ 
+    maxPending: Infinity,
+    timeout: 5000 // 5s timeout to prevent deadlocks
+});
+const globalAuthLock = new async_lock_1.default(); // Additional global lock
+
+// Debugging utilities
+let AUTH_DEBUG = false;
+function authDebug(...args) {
+    if (AUTH_DEBUG) {
+        console.log('[AUTH DEBUG]', new Date().toISOString(), ...args);
+    }
+}
+
+/**
+ * Enhanced multi-file auth state storage with:
+ * - Better error handling
+ * - Additional locking
+ * - Data validation
+ * - Auto-repair mechanisms
+ */
+const useMultiFileAuthState = async (folder, options = {}) => {
+    AUTH_DEBUG = options.authDebug ?? false;
+    const cache = options.syncCache ? new node_cache_1.default({
+      stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+      useClones: false,
+      deleteOnExpire: true,
+      checkperiod: 120
+    }) : null;
+    // Validate and prepare folder
+    const prepareFolder = async () => {
+        try {
+            const folderInfo = await (0, promises_1.stat)(folder).catch(() => null);
+            
+            if (folderInfo) {
+                if (!folderInfo.isDirectory()) {
+                    throw new Error(`Path exists but is not a directory: ${folder}`);
+                }
+            } else {
+                authDebug('Creating auth folder:', folder);
+                await (0, promises_1.mkdir)(folder, { recursive: true });
+            }
+            
+            // Verify folder is writable
+            await testFolderAccess();
+        } catch (error) {
+            authDebug('Folder preparation failed:', error);
+            throw new Error(`Auth folder initialization failed: ${error.message}`);
+        }
+    };
+
+    const testFolderAccess = async () => {
+        const testFile = (0, path_1.join)(folder, '.temp_test');
+        try {
+            await (0, promises_1.writeFile)(testFile, 'test');
+            await (0, promises_1.unlink)(testFile);
+        } catch (error) {
+            throw new Error(`Folder not writable: ${error.message}`);
+        }
+    };
+
+    const fixFileName = (file) => {
+        if (!file) return file;
+        return file.replace(/\//g, '__').replace(/:/g, '-');
+    };
+    
+    function getUniqueId(type, id) {
+        return `${type}.${id}`;
+    }
+
+    // Enhanced write with retries
+    const writeData = async (data, file) => {
+        return globalAuthLock.acquire('write', async () => {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            let attempts = 0;
+            const maxAttempts = 3;
+            
+            while (attempts < maxAttempts) {
+                attempts++;
+                try {
+                    await fileLock.acquire(filePath, async () => {
+                        const serialized = JSON.stringify(data, generics_1.BufferJSON.replacer);
+                        await (0, promises_1.writeFile)(filePath, serialized);
+                        authDebug('Write successful:', file);
+                    });
+                    return;
+                } catch (error) {
+                    authDebug(`Write attempt ${attempts} failed for ${file}:`, error);
+                    if (attempts >= maxAttempts) {
+                        throw new Error(`Failed to write after ${maxAttempts} attempts: ${error.message}`);
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 100 * attempts));
+                }
+            }
+        });
+    };
+
+    // Enhanced read with validation
+    const readData = async (file) => {
+        return globalAuthLock.acquire('read', async () => {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            
+            try {
+                const data = await fileLock.acquire(filePath, async () => {
+                    const content = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
+                    authDebug('Read successful:', file);
+                    return content;
+                });
+                
+                const parsed = JSON.parse(data, generics_1.BufferJSON.reviver);
+                
+                // Basic data validation
+                if (file === 'creds.json' && !parsed.me) {
+                    authDebug('Invalid creds data detected');
+                    return null;
+                }
+                
+                return parsed;
+            } catch (error) {
+                if (error.code !== 'ENOENT') { // Ignore "file not found" errors
+                    authDebug('Read error:', file, error);
+                }
+                return null;
+            }
+        });
+    };
+
+    // Safe removal
+    const removeData = async (file) => {
+        return globalAuthLock.acquire('remove', async () => {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            
+            try {
+                await fileLock.acquire(filePath, async () => {
+                    await (0, promises_1.unlink)(filePath);
+                    authDebug('Removed:', file);
+                });
+            } catch (error) {
+                if (error.code !== 'ENOENT') { // Ignore "file not found" errors
+                    authDebug('Remove error:', file, error);
+                }
+            }
+        });
+    };
+
+    // Initialize
+    await prepareFolder();
+    
+    // Load or initialize credentials
+    let creds = await readData('creds.json');
+    if (!creds) {
+        authDebug('No existing creds found, initializing new ones');
+        creds = (0, auth_utils_1.initAuthCreds)();
+        await writeData(creds, 'creds.json');
+    }
+    
+    async function warmUpCache() {
+      try {
+        const files = await promises_1.readdir(folder);
+        for (const file of files) {
+          if (file.endsWith('.json') && file !== 'creds.json') {
+            const parts = file.split('-');
+            if (parts.length === 2) {
+              const type = parts[0];
+              const id = parts[1].replace('.json', '');
+              const data = await readData(file);
+              if (data) {
+                cache.set(getUniqueId(type, id), data);
+                authDebug(`Cache warmed: ${type}-${id}`);
+              }
+            }
+          }
+        }
+      } catch (error) {
+        authDebug('Cache warm-up failed:', error);
+      }
+    }
+    
+    if (cache) warmUpCache();
+
+    // Auto-save mechanism
+    let saveTimeout;
+    const scheduleSave = () => {
+       if (saveTimeout) clearTimeout(saveTimeout);
+       saveTimeout = setTimeout(() => {
+           saveCreds().catch(error => {
+               authDebug('Auto-save failed, retrying sooner:', error);
+               setTimeout(scheduleSave, 60000);
+           });
+       }, 180000);
+    };
+    // Enhanced save function
+    const saveCreds = async () => {
+        try {
+            await writeData(creds, 'creds.json');
+            scheduleSave();
+        } catch (error) {
+            authDebug('Critical: Creds save failed:', error);
+            throw error;
+        }
+    };
+    
+    process.on('beforeExit', async () => {
+      if (saveTimeout) clearTimeout(saveTimeout);
+      await saveCreds().catch(error => {
+        authDebug('Emergency save failed:', error);
+      });
+    });
+    
+    process.on('uncaughtException', async (error) => {
+      authDebug('Uncaught exception, attempting emergency save:', error);
+      if (saveTimeout) clearTimeout(saveTimeout);
+      await saveCreds().catch(e => {
+        authDebug('Emergency save failed:', e);
+      });
+      process.exit(1);
+    });
+    // Start auto-save loop
+    scheduleSave();
+
+    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) {
+                            try {
+                                value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                            } catch (error) {
+                                authDebug('Key conversion failed:', type, id, error);
+                                value = null;
+                            }
+                        }
+                        
+                        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`;
+                            
+                            if (value) {
+                                tasks.push(writeData(value, file));
+                            } else {
+                                tasks.push(removeData(file));
+                            }
+                        }
+                    }
+                    
+                    try {
+                        await Promise.all(tasks);
+                    } catch (error) {
+                        authDebug('Bulk key update failed:', error);
+                        throw error;
+                    }
+                }
+            }
+        },
+        saveCreds,
+        // Additional maintenance API
+        cleanup: async () => {
+            if (saveTimeout) clearTimeout(saveTimeout);
+            await saveCreds();
+        },
+        cache
+    };
+};
+exports.useMultiFileAuthState = useMultiFileAuthState;

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

@@ -0,0 +1,12 @@
+import type { Logger } from 'pino';
+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?: Logger) => {
+    state: AuthenticationState;
+    saveState: () => void;
+};

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSingleFileAuthState = void 0;
+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 = (0, auth_utils_1.initAuthCreds)();
+        keys = {};
+    }
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const key = KEY_MAP[type];
+                    return ids.reduce((dict, id) => {
+                        var _a;
+                        let value = (_a = keys[key]) === null || _a === void 0 ? void 0 : _a[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
+    };
+};
+exports.useSingleFileAuthState = useSingleFileAuthState;

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

@@ -0,0 +1,11 @@
+import { proto } from '../../WAProto';
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const generateMobileNode: (config: SocketConfig) => proto.IClientPayload;
+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;