@codexverified/baileys 2.7.5

package/lib/Utils/use-sqlite-auth-state.js

@@ -0,0 +1,108 @@
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+async function loadBetterSqlite3() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = (await import('better-sqlite3'));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for `useSqliteAuthState`. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+const CREDS_ROW_KEY = '__creds__';
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS creds (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS signal_keys (
+  type TEXT NOT NULL,
+  id TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (type, id)
+);
+CREATE INDEX IF NOT EXISTS signal_keys_type_idx ON signal_keys(type);
+`;
+export async function useSqliteAuthState(opts) {
+    let db;
+    if (opts.database) {
+        db = opts.database;
+    }
+    else {
+        const Database = await loadBetterSqlite3();
+        db = new Database(opts.dbPath);
+    }
+    // WAL mode allows concurrent reads alongside a single writer; matches
+    // what SQLite recommends for read-heavy workloads with sporadic writes.
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.exec(CREATE_SCHEMA_SQL);
+    const stmts = {
+        credsSelect: db.prepare('SELECT value FROM creds WHERE key = ?'),
+        credsUpsert: db.prepare('INSERT INTO creds (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'),
+        keySelect: db.prepare('SELECT value FROM signal_keys WHERE type = ? AND id = ?'),
+        keyUpsert: db.prepare('INSERT INTO signal_keys (type, id, value) VALUES (?, ?, ?) ON CONFLICT(type, id) DO UPDATE SET value = excluded.value'),
+        keyDelete: db.prepare('DELETE FROM signal_keys WHERE type = ? AND id = ?'),
+        keyListIds: db.prepare('SELECT id FROM signal_keys WHERE type = ?'),
+        keyList: db.prepare('SELECT id, value FROM signal_keys WHERE type = ?'),
+        clearKeys: db.prepare('DELETE FROM signal_keys')
+    };
+    const loadCreds = () => {
+        const row = stmts.credsSelect.get(CREDS_ROW_KEY);
+        if (!row)
+            return initAuthCreds();
+        return JSON.parse(row.value, BufferJSON.reviver);
+    };
+    const persistCreds = (creds) => {
+        stmts.credsUpsert.run(CREDS_ROW_KEY, JSON.stringify(creds, BufferJSON.replacer));
+    };
+    const creds = loadCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const row = stmts.keySelect.get(type, id);
+                        if (row) {
+                            let value = JSON.parse(row.value, BufferJSON.reviver);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            data[id] = value;
+                        }
+                    }
+                    return data;
+                },
+                set: async (data) => {
+                    const writeTx = db.transaction(() => {
+                        for (const category in data) {
+                            for (const id in data[category]) {
+                                const value = data[category][id];
+                                if (value) {
+                                    const stringified = JSON.stringify(value, BufferJSON.replacer);
+                                    stmts.keyUpsert.run(category, id, stringified);
+                                }
+                                else {
+                                    stmts.keyDelete.run(category, id);
+                                }
+                            }
+                        }
+                    });
+                    writeTx();
+                }
+            }
+        },
+        saveCreds: async () => {
+            persistCreds(creds);
+        }
+    };
+}

package/lib/Utils/validate-connection.js

@@ -0,0 +1,206 @@
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { KEY_BUNDLE_TYPE, WA_ADV_ACCOUNT_SIG_PREFIX, WA_ADV_DEVICE_SIG_PREFIX, WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX } from '../Defaults/index.js';
+import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { Curve, hmacSign } from './crypto.js';
+import { encodeBigEndian } from './generics.js';
+import { createSignalIdentity } from './signal.js';
+const getUserAgent = (config) => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2]
+        },
+        platform: config.browser[1].toLocaleLowerCase().includes('android')
+            ? proto.ClientPayload.UserAgent.Platform.ANDROID
+            : proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        localeLanguageIso6391: 'en',
+        mnc: '000',
+        mcc: '000',
+        localeCountryIso31661Alpha2: config.countryCode
+    };
+};
+const PLATFORM_MAP = {
+    'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+};
+const getWebInfo = (config) => {
+    let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    if (config.syncFullHistory &&
+        PLATFORM_MAP[config.browser[0]] &&
+        config.browser[1] === 'Desktop') {
+        webSubPlatform = PLATFORM_MAP[config.browser[0]];
+    }
+    return { webSubPlatform };
+};
+const getClientPayload = (config) => {
+    const payload = {
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
+    };
+    if (!config.browser[1].toLocaleLowerCase().includes('android')) {
+        payload.webInfo = getWebInfo(config);
+    }
+    return payload;
+};
+export const generateLoginNode = (userJid, config) => {
+    const { user, device } = jidDecode(userJid);
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        pull: true,
+        username: +user,
+        device: device,
+        // TODO: investigate (hard set as false atm)
+        lidDbMigrated: false
+    };
+    return proto.ClientPayload.fromObject(payload);
+};
+const getPlatformType = (platform) => {
+    const platformType = platform.toUpperCase();
+    if (platformType === 'ANDROID') {
+        return proto.DeviceProps.PlatformType.ANDROID_PHONE;
+    }
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.CHROME);
+};
+export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    // the app version needs to be md5 hashed
+    // and passed in
+    const appVersionBuf = createHash('md5')
+        .update(config.version.join('.')) // join as string
+        .digest();
+    const companion = {
+        os: config.browser[0],
+        platformType: getPlatformType(config.browser[1]),
+        requireFullSync: config.syncFullHistory,
+        historySyncConfig: {
+            storageQuotaMb: 10240,
+            inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
+            supportCallLogHistory: false,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportBizHostedMsg: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportFbidBotChatHistory: true,
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
+        },
+        version: {
+            primary: 10,
+            secondary: 15,
+            tertiary: 7
+        }
+    };
+    const companionProto = proto.DeviceProps.encode(companion).finish();
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
+            eSkeyVal: signedPreKey.keyPair.public,
+            eSkeySig: signedPreKey.signature
+        }
+    };
+    return proto.ClientPayload.fromObject(registerPayload);
+};
+export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+    const msgId = stanza.attrs.id;
+    const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success');
+    const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity');
+    const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform');
+    const deviceNode = getBinaryNodeChild(pairSuccessNode, 'device');
+    const businessNode = getBinaryNodeChild(pairSuccessNode, 'biz');
+    if (!deviceIdentityNode || !deviceNode) {
+        throw new Boom('Missing device-identity or device in pair success node', { data: stanza });
+    }
+    const bizName = businessNode?.attrs.name;
+    const jid = deviceNode.attrs.jid;
+    const lid = deviceNode.attrs.lid;
+    const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    let hmacPrefix = Buffer.from([]);
+    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
+    }
+    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    if (Buffer.compare(hmac, advSign) !== 0) {
+        throw new Boom('Invalid account signature');
+    }
+    const account = proto.ADVSignedDeviceIdentity.decode(details);
+    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
+    const deviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails);
+    const accountSignaturePrefix = deviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
+        ? WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : WA_ADV_ACCOUNT_SIG_PREFIX;
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
+    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new Boom('Failed to verify account signature');
+    }
+    const deviceMsg = Buffer.concat([
+        WA_ADV_DEVICE_SIG_PREFIX,
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
+    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = createSignalIdentity(lid, accountSignatureKey);
+    const accountEnc = encodeSignedDeviceIdentity(account, false);
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: S_WHATSAPP_NET,
+            type: 'result',
+            id: msgId
+        },
+        content: [
+            {
+                tag: 'pair-device-sign',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'device-identity',
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+                        content: accountEnc
+                    }
+                ]
+            }
+        ]
+    };
+    const authUpdate = {
+        account,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
+    };
+    return {
+        creds: authUpdate,
+        reply
+    };
+};
+export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    account = { ...account };
+    // set to null if we are not to include the signature key
+    // or if we are including the signature key but it is empty
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null;
+    }
+    return proto.ADVSignedDeviceIdentity.encode(account).finish();
+};

package/lib/Utils/voip-rekey.js

@@ -0,0 +1,20 @@
+import { proto } from '../../WAProto/index.js';
+
+const REKEY_TYPE_NAMES = {
+    [proto.RekeyKeyType.REKEY_KEY_AUDIO]: 'REKEY_KEY_AUDIO',
+    [proto.RekeyKeyType.REKEY_KEY_VIDEO]: 'REKEY_KEY_VIDEO',
+    [proto.RekeyKeyType.REKEY_KEY_APPDATA]: 'REKEY_KEY_APPDATA'
+};
+
+export const decodeE2eRekeyPayload = (buffer) => {
+    if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+        throw new TypeError('decodeE2eRekeyPayload: buffer must be Buffer or Uint8Array');
+    }
+    const decoded = proto.E2eRekeyPayload.decode(buffer);
+    return {
+        keys: (decoded.keys || []).map(entry => ({
+            type: REKEY_TYPE_NAMES[entry.type] ?? entry.type,
+            key: entry.key ? Buffer.from(entry.key) : Buffer.alloc(0)
+        }))
+    };
+};

package/lib/Utils/welcome-flow.js

@@ -0,0 +1,217 @@
+/**
+ * Lia@Changes [WIP]
+ * Welcome Flow  Meta Business-style startup template.
+ *
+ * Fires automatically on first message from any new contact.
+ * Sends a fully configurable greeting with interactive FAQ buttons,
+ * exactly like Meta Business account welcome templates.
+ *
+ * Tracks seen JIDs in memory + optional persistent JSON file so the
+ * greeting fires ONCE per contact  never on repeat messages.
+ *
+ * Usage:
+ *   const welcome = createWelcomeFlow(sock, config)
+ *   welcome.listen()       // start listening
+ *   welcome.stop()         // stop listening
+ *   welcome.reset(jid)     // force re-greet a contact
+ *   welcome.resetAll()     // clear all seen contacts
+ *
+ * If you use or copy this code, please credit @codexverified/baileys.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { isJidGroup, isJidNewsletter, isJidBroadcast, jidNormalizedUser } from '../WABinary/index.js';
+import { delay } from './generics.js';
+
+//  Defaults 
+
+const DEFAULT_CONFIG = {
+    greeting: ' Welcome! How can I help you today?',
+    footer: 'Powered by @codexverified/baileys',
+    buttonText: ' Choose an option',
+    faqs: [
+        { id: 'faq_1', title: ' Track my order',       description: 'Check order status' },
+        { id: 'faq_2', title: ' Billing & payments',   description: 'Payment issues & invoices' },
+        { id: 'faq_3', title: ' Technical support',    description: 'Get help with a problem' },
+        { id: 'faq_4', title: ' Talk to a human',      description: 'Connect with support staff' },
+    ],
+    sectionTitle: 'How can we help?',
+    typingDelayMs: 1200,        // simulate typing before greeting appears
+    persistPath: null,          // set to a file path to persist seen JIDs across restarts
+    ignoreGroups: true,         // don't fire in group chats
+    ignoreNewsletter: true,     // don't fire for newsletter messages
+    ignoreBroadcast: true,      // don't fire for broadcast messages
+    onGreet: null,              // async (jid, message) => {}  called after greeting sent
+    onFaqReply: null,           // async (jid, faqId, message) => {}  called when user picks a FAQ
+};
+
+//  Persistent seen-JID store 
+
+const createSeenStore = (persistPath) => {
+    const seen = new Set();
+
+    // Load from file if path given and file exists
+    if (persistPath && existsSync(persistPath)) {
+        try {
+            const data = JSON.parse(readFileSync(persistPath, 'utf8'));
+            if (Array.isArray(data)) data.forEach(jid => seen.add(jid));
+        } catch (_) {}
+    }
+
+    const save = () => {
+        if (!persistPath) return;
+        try {
+            writeFileSync(persistPath, JSON.stringify([...seen]), 'utf8');
+        } catch (_) {}
+    };
+
+    return {
+        has: (jid) => seen.has(jid),
+        add: (jid) => { seen.add(jid); save(); },
+        delete: (jid) => { seen.delete(jid); save(); },
+        clear: () => { seen.clear(); save(); }
+    };
+};
+
+//  Build the welcome interactive list message 
+
+const buildWelcomeMessage = (config, quotedMsg = null) => {
+    const { greeting, footer, buttonText, faqs, sectionTitle } = config;
+
+    const content = {
+        text: greeting,
+        footer,
+        buttonText,
+        sections: [
+            {
+                title: sectionTitle,
+                rows: faqs.map(faq => ({
+                    title: faq.title,
+                    description: faq.description || '',
+                    rowId: faq.id
+                }))
+            }
+        ]
+    };
+
+    if (quotedMsg) {
+        content.quoted = quotedMsg;
+    }
+
+    return content;
+};
+
+//  Main factory 
+
+/**
+ * createWelcomeFlow  attach a Meta Business-style welcome template to a socket.
+ *
+ * @param {object} sock    - Baileys socket
+ * @param {object} config  - Partial config  merges with DEFAULT_CONFIG
+ * @returns {{ listen, stop, reset, resetAll }}
+ */
+export const createWelcomeFlow = (sock, config = {}) => {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const seen = createSeenStore(cfg.persistPath);
+
+    //  FAQ reply handler  called when user selects a list option 
+    const handleFaqReply = async (msg) => {
+        if (typeof cfg.onFaqReply !== 'function') return;
+        const reply = msg.message?.listResponseMessage;
+        if (!reply) return;
+        const faqId = reply.singleSelectReply?.selectedRowId;
+        const jid = jidNormalizedUser(msg.key.remoteJid);
+        if (faqId) {
+            await cfg.onFaqReply(jid, faqId, msg);
+        }
+    };
+
+    //  First-message handler 
+    const handleMessage = async ({ messages, type }) => {
+        if (type !== 'notify') return;
+
+        for (const msg of messages) {
+            try {
+                const jid = msg.key?.remoteJid;
+                if (!jid || msg.key?.fromMe) continue;
+
+                // Skip ignored JID types
+                if (cfg.ignoreGroups && isJidGroup(jid)) continue;
+                if (cfg.ignoreNewsletter && isJidNewsletter(jid)) continue;
+                if (cfg.ignoreBroadcast && isJidBroadcast(jid)) continue;
+
+                const normalizedJid = jidNormalizedUser(jid);
+
+                // Check if it's a FAQ reply first
+                if (msg.message?.listResponseMessage) {
+                    await handleFaqReply(msg);
+                    continue;
+                }
+
+                // Already greeted this contact  skip
+                if (seen.has(normalizedJid)) continue;
+
+                // Mark as seen immediately to prevent race conditions
+                seen.add(normalizedJid);
+
+                // Simulate typing before the greeting
+                if (cfg.typingDelayMs > 0) {
+                    await sock.sendPresenceUpdate('composing', jid);
+                    await delay(cfg.typingDelayMs);
+                    await sock.sendPresenceUpdate('paused', jid);
+                }
+
+                // Send the welcome message
+                const welcomeContent = buildWelcomeMessage(cfg, msg);
+                await sock.sendMessage(jid, welcomeContent);
+
+                // Fire onGreet callback if provided
+                if (typeof cfg.onGreet === 'function') {
+                    await cfg.onGreet(normalizedJid, msg).catch(() => {});
+                }
+            } catch (_) {}
+        }
+    };
+
+    //  Public API 
+    return {
+        /**
+         * Start listening for new contacts.
+         */
+        listen() {
+            sock.ev.on('messages.upsert', handleMessage);
+        },
+
+        /**
+         * Stop listening.
+         */
+        stop() {
+            sock.ev.off('messages.upsert', handleMessage);
+        },
+
+        /**
+         * Force re-greet a specific contact next time they message.
+         * @param {string} jid
+         */
+        reset(jid) {
+            seen.delete(jidNormalizedUser(jid));
+        },
+
+        /**
+         * Clear all seen contacts  everyone gets re-greeted.
+         */
+        resetAll() {
+            seen.clear();
+        },
+
+        /**
+         * Check if a contact has already been greeted.
+         * @param {string} jid
+         * @returns {boolean}
+         */
+        hasGreeted(jid) {
+            return seen.has(jidNormalizedUser(jid));
+        }
+    };
+};
+