jsdecryptor 4.0.3

package/davexcore/anti/antibadword.js

@@ -0,0 +1,313 @@
+const { getGroupConfig, setGroupConfig, parseToggleCommand, parseActionCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const DEFAULT_BAD_WORDS = [
+    'gandu', 'madarchod', 'bhosdike', 'bsdk', 'fucker', 'bhosda', 
+    'lauda', 'laude', 'betichod', 'chutiya', 'behenchod', 
+    'randi', 'chuchi', 'boobs', 'idiot', 'nigga', 'fuck', 
+    'dick', 'bitch', 'bastard', 'asshole', 'lund', 'mc', 'lodu',
+    'shit', 'damn', 'piss', 'crap', 'slut', 'whore', 'prick',
+    'motherfucker', 'cock', 'cunt', 'pussy', 'twat', 'wanker',
+    'chut', 'harami', 'kameena', 'haramzada'
+];
+
+async function handleAntiBadwordCommand(sock, chatId, message, match) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const botName = getBotName();
+    
+    try {
+        const groupMetadata = await sock.groupMetadata(chatId);
+        const participant = groupMetadata.participants.find(p => p.id === senderId);
+        if (!participant?.admin && !message.key.fromMe && !db.isSudo(senderId)) {
+            const fake = createFakeContact(senderId);
+            return sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAdmin only command!` 
+            }, { quoted: fake });
+        }
+    } catch {}
+
+    const fake = createFakeContact(senderId);
+    const config = getGroupConfig(chatId, 'antibadword');
+
+    if (!match) {
+        const words = config.words?.length > 0 ? config.words : DEFAULT_BAD_WORDS;
+        const helpText = `*${botName} ANTIBADWORD*\n\n` +
+                        `Status: ${config.enabled ? 'ON' : 'OFF'}\n` +
+                        `Action: ${config.action || 'delete'}\n` +
+                        `Max Warnings: ${config.maxWarnings || 3}\n` +
+                        `Custom Words: ${config.words?.length || 0}\n\n` +
+                        `*Commands:*\n` +
+                        `.antibadword on - Enable\n` +
+                        `.antibadword off - Disable\n` +
+                        `.antibadword delete - Delete messages\n` +
+                        `.antibadword kick - Kick user\n` +
+                        `.antibadword warn - Warn user\n` +
+                        `.antibadword add <word1,word2> - Add words\n` +
+                        `.antibadword remove <word> - Remove word\n` +
+                        `.antibadword list - Show word list\n` +
+                        `.antibadword setwarn <num> - Set max warnings\n` +
+                        `.antibadword reset - Reset to default words`;
+        
+        await sock.sendMessage(chatId, { text: helpText }, { quoted: fake });
+        return;
+    }
+
+    let newConfig = { ...config };
+    let responseText = '';
+    const sub = match.toLowerCase().trim();
+
+    if (sub === 'status') {
+        responseText = `*${botName} ANTIBADWORD STATUS*\n\n` +
+                      `Status: ${config.enabled ? 'ACTIVE' : 'INACTIVE'}\n` +
+                      `Action: ${config.action || 'delete'}\n` +
+                      `Max Warnings: ${config.maxWarnings || 3}\n` +
+                      `Custom Words: ${config.words?.length || 0}`;
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+        return;
+    }
+
+    if (sub === 'list') {
+        const customWords = Array.isArray(config.words) ? config.words : [];
+        const allWords = [...new Set([...DEFAULT_BAD_WORDS, ...customWords])];
+        let listText = `*${botName} BADWORD LIST*\n\n`;
+        listText += `Default words: ${DEFAULT_BAD_WORDS.length}\n`;
+        listText += `Custom words: ${customWords.length}\n`;
+        listText += `Total detected: ${allWords.length}\n\n`;
+        if (customWords.length > 0) {
+            listText += `*Custom words:*\n${customWords.join(', ')}\n\n`;
+        }
+        listText += `*Default words:*\n${DEFAULT_BAD_WORDS.slice(0, 30).join(', ')}`;
+        if (DEFAULT_BAD_WORDS.length > 30) listText += `\n...and ${DEFAULT_BAD_WORDS.length - 30} more`;
+        responseText = listText;
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+        return;
+    }
+
+    if (sub.startsWith('add ')) {
+        const rawInput = sub.slice(4).trim();
+        const wordsToAdd = rawInput.split(/[,\s]+/).map(w => w.trim().toLowerCase()).filter(w => w.length > 1);
+        if (wordsToAdd.length > 0) {
+            // Use existing custom words only; don't fall back to defaults so new words aren't shadowed
+            const currentWords = Array.isArray(config.words) ? [...config.words] : [];
+            const addedWords = [];
+            for (const word of wordsToAdd) {
+                if (!currentWords.includes(word)) {
+                    currentWords.push(word);
+                    addedWords.push(word);
+                }
+            }
+            newConfig.words = currentWords;
+            setGroupConfig(chatId, 'antibadword', newConfig);
+            if (addedWords.length > 0) {
+                responseText = `*${botName}*\n✅ Added ${addedWords.length} word(s): ${addedWords.join(', ')}\nTotal custom words: ${currentWords.length}`;
+            } else {
+                responseText = `*${botName}*\nAll those words are already in the list!\nCurrent list: ${currentWords.length} custom word(s)`;
+            }
+        } else {
+            responseText = `*${botName}*\nProvide words to add! Example: .antibadword add badword1,badword2`;
+        }
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+        return;
+    }
+
+    if (sub.startsWith('remove ')) {
+        const wordToRemove = sub.slice(7).trim().toLowerCase();
+        const currentWords = Array.isArray(config.words) ? [...config.words] : [];
+        const index = currentWords.indexOf(wordToRemove);
+        if (index > -1) {
+            currentWords.splice(index, 1);
+            newConfig.words = currentWords;
+            setGroupConfig(chatId, 'antibadword', newConfig);
+            responseText = `*${botName}*\n✅ Removed: ${wordToRemove}\nRemaining custom words: ${currentWords.length}`;
+        } else {
+            responseText = `*${botName}*\n❌ "${wordToRemove}" not found in custom word list!\nUse .antibadword list to see all words`;
+        }
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+        return;
+    }
+
+    if (sub.startsWith('setwarn ')) {
+        const num = parseInt(sub.replace('setwarn ', '').trim());
+        if (num > 0 && num <= 10) {
+            newConfig.maxWarnings = num;
+            setGroupConfig(chatId, 'antibadword', newConfig);
+            responseText = `*${botName}*\nMax warnings set to: ${num}`;
+        } else {
+            responseText = `*${botName}*\nInvalid number! Use 1-10`;
+        }
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+        return;
+    }
+
+    if (sub === 'reset') {
+        newConfig.words = [...DEFAULT_BAD_WORDS];
+        setGroupConfig(chatId, 'antibadword', newConfig);
+        responseText = `*${botName}*\nReset to default ${DEFAULT_BAD_WORDS.length} words`;
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+        return;
+    }
+
+    const toggle = parseToggleCommand(sub);
+    if (toggle === 'on') {
+        newConfig.enabled = true;
+        responseText = `*${botName}*\nAntiBadword ENABLED\nAction: ${newConfig.action || 'delete'}`;
+    } else if (toggle === 'off') {
+        newConfig.enabled = false;
+        responseText = `*${botName}*\nAntiBadword DISABLED`;
+    } else {
+        const action = parseActionCommand(sub);
+        if (action === 'delete') {
+            newConfig.action = 'delete';
+            newConfig.enabled = true;
+            responseText = `*${botName}*\nAction: DELETE\nBad word messages will be deleted.`;
+        } else if (action === 'kick') {
+            newConfig.action = 'kick';
+            newConfig.enabled = true;
+            responseText = `*${botName}*\nAction: KICK\nUsers will be removed for bad words.`;
+        } else if (action === 'warn') {
+            newConfig.action = 'warn';
+            newConfig.enabled = true;
+            responseText = `*${botName}*\nAction: WARN\nUsers get ${newConfig.maxWarnings || 3} warnings before kick.`;
+        } else {
+            responseText = `*${botName}*\nInvalid command!\nUse: on, off, delete, kick, warn, add, remove, list`;
+        }
+    }
+
+    if (responseText && !responseText.includes('Invalid')) {
+        setGroupConfig(chatId, 'antibadword', newConfig);
+    }
+
+    await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+}
+
+function normalizeJid(jid) {
+    if (!jid) return '';
+    const num = jid.split('@')[0].split(':')[0];
+    return num + '@s.whatsapp.net';
+}
+
+async function handleBadwordDetection(sock, chatId, message, userMessage, senderId) {
+    try {
+        if (!chatId.endsWith('@g.us')) return;
+        if (message.key.fromMe) return;
+        
+        const config = getGroupConfig(chatId, 'antibadword');
+        if (!config?.enabled) return;
+
+        const groupMetadata = await sock.groupMetadata(chatId);
+        const botId = normalizeJid(sock.user.id);
+        const normalizedSender = normalizeJid(senderId);
+        const bot = groupMetadata.participants.find(p => normalizeJid(p.id) === botId);
+        if (!bot?.admin) return;
+
+        const participant = groupMetadata.participants.find(p => normalizeJid(p.id) === normalizedSender);
+        if (participant?.admin) return;
+        if (db.isSudo(senderId) || db.isSudo(normalizedSender)) return;
+
+        const cleanMessage = userMessage.toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+
+        // Always include both custom words AND defaults for detection
+        const customWords = Array.isArray(config.words) ? config.words : [];
+        const badWords = [...new Set([...DEFAULT_BAD_WORDS, ...customWords])];
+        const messageWords = cleanMessage.split(' ');
+        let containsBadWord = false;
+        let detectedWord = '';
+
+        for (const word of messageWords) {
+            if (word.length < 2) continue;
+            if (badWords.includes(word)) {
+                containsBadWord = true;
+                detectedWord = word;
+                break;
+            }
+        }
+
+        for (const badWord of badWords) {
+            if (badWord.includes(' ') && cleanMessage.includes(badWord)) {
+                containsBadWord = true;
+                detectedWord = badWord;
+                break;
+            }
+        }
+
+        if (!containsBadWord) return;
+
+        const botName = getBotName();
+        const fake = createFakeContact(senderId);
+
+        try {
+            await sock.sendMessage(chatId, { delete: message.key });
+        } catch (err) {
+            console.error('Error deleting message:', err.message);
+            return;
+        }
+
+        const action = config.action || 'delete';
+        const senderNumber = senderId.split('@')[0];
+        const maxWarnings = config.maxWarnings || 3;
+
+        switch (action) {
+            case 'delete':
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n@${senderNumber}, bad words not allowed!\nMessage deleted.`,
+                    mentions: [senderId]
+                }, { quoted: fake });
+                break;
+
+            case 'kick':
+                try {
+                    await sock.groupParticipantsUpdate(chatId, [senderId], 'remove');
+                    await sock.sendMessage(chatId, {
+                        text: `*${botName}*\n@${senderNumber} kicked for bad words!`,
+                        mentions: [senderId]
+                    }, { quoted: fake });
+                } catch (error) {
+                    console.error('Error kicking user:', error.message);
+                }
+                break;
+
+            case 'warn':
+                const warningCount = db.incrementWarning(chatId, senderId);
+                if (warningCount >= maxWarnings) {
+                    try {
+                        await sock.groupParticipantsUpdate(chatId, [senderId], 'remove');
+                        db.resetWarning(chatId, senderId);
+                        await sock.sendMessage(chatId, {
+                            text: `*${botName}*\n@${senderNumber} kicked after ${maxWarnings} warnings!`,
+                            mentions: [senderId]
+                        }, { quoted: fake });
+                    } catch (error) {
+                        console.error('Error kicking user after warnings:', error.message);
+                    }
+                } else {
+                    await sock.sendMessage(chatId, {
+                        text: `*${botName}*\n@${senderNumber} warning ${warningCount}/${maxWarnings}!\nBad words not allowed.`,
+                        mentions: [senderId]
+                    }, { quoted: fake });
+                }
+                break;
+        }
+    } catch (err) {
+        console.error('Error in handleBadwordDetection:', err.message, 'Line:', err.stack?.split('\n')[1]);
+    }
+}
+
+async function antibadwordCommand(sock, chatId, message, args) {
+    try {
+        await handleAntiBadwordCommand(sock, chatId, message, args || '');
+    } catch (error) {
+        console.error('Error in antibadword command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        const botName = getBotName();
+        await sock.sendMessage(chatId, { text: `*${botName}*\nError processing command!` });
+    }
+}
+
+module.exports = {
+    handleAntiBadwordCommand,
+    handleBadwordDetection,
+    antibadwordCommand
+};

package/davexcore/anti/antibug.js

@@ -0,0 +1,156 @@
+const { getGroupConfig, setGroupConfig, deleteGroupToggle, getOwnerConfig, setOwnerConfig } = require('../../Database/settingsStore');
+const { isBugMessage } = require('../../davelib/index');
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function antibugCommand(sock, chatId, userMessage, senderId, isSenderAdmin, message) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+        const isGroup = chatId.endsWith('@g.us');
+
+        if (isGroup) {
+            if (!isSenderAdmin && !message?.key?.fromMe && !db.isSudo(senderId)) {
+                await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+                return;
+            }
+        } else {
+            if (!message?.key?.fromMe && !db.isSudo(senderId)) {
+                await sock.sendMessage(chatId, { text: `*${botName}*\nOwner only command!` }, { quoted: fake });
+                return;
+            }
+        }
+
+        const args = userMessage.slice(8).toLowerCase().trim().split(' ');
+        const action = args[0];
+
+        const config = isGroup 
+            ? (getGroupConfig(chatId, 'antibug') || { enabled: false })
+            : (getOwnerConfig('antibug_pm') || { enabled: false });
+        const currentMode = config.enabled ? (config.action || 'delete') : 'off';
+
+        const { getPrefix } = require('../owner/setprefix');
+        const p = getPrefix();
+
+        if (!action) {
+            const scope = isGroup ? 'GROUP' : 'PM';
+            const usage = `*${botName} ANTI-BUG (${scope})*\n\nCurrent Mode: ${currentMode.toUpperCase()}\n\n*Commands:*\n${p}antibug off - Disable\n${p}antibug delete - Delete bug messages\n${p}antibug warn - Delete + warn\n${p}antibug kick - Delete + kick${!isGroup ? '\n\nIn PM: blocks bug senders' : ''}`;
+
+            await sock.sendMessage(chatId, { text: usage }, { quoted: fake });
+            return;
+        }
+
+        const validModes = ["off", "delete", "warn", "kick"];
+
+        if (!validModes.includes(action)) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nInvalid mode! Use: off, delete, warn, kick` 
+            }, { quoted: fake });
+            return;
+        }
+
+        if (action === 'off') {
+            if (isGroup) {
+                deleteGroupToggle(chatId, 'antibug');
+            } else {
+                setOwnerConfig('antibug_pm', { enabled: false });
+            }
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAnti-Bug DISABLED` 
+            }, { quoted: fake });
+        } else {
+            const newConf = { enabled: true, action: action };
+            if (isGroup) {
+                setGroupConfig(chatId, 'antibug', newConf);
+            } else {
+                setOwnerConfig('antibug_pm', newConf);
+            }
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAnti-Bug: ${action.toUpperCase()}${!isGroup ? ' (PM)' : ''}` 
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in antibug command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+async function handleBugDetection(sock, chatId, message, senderId) {
+    try {
+        if (!isBugMessage(message)) return;
+
+        const isGroup = chatId.endsWith('@g.us');
+
+        if (isGroup) {
+            const config = getGroupConfig(chatId, 'antibug');
+            if (!config || !config.enabled) return;
+
+            const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+            if (!isBotAdmin || isSenderAdmin || db.isSudo(senderId)) return;
+
+            const botName = getBotName();
+            const userTag = `@${senderId.split("@")[0]}`;
+            const fake = createFakeContact(senderId);
+
+            try {
+                await sock.sendMessage(chatId, {
+                    delete: {
+                        remoteJid: chatId,
+                        fromMe: false,
+                        id: message.key.id,
+                        participant: senderId
+                    }
+                });
+            } catch (e) {
+                console.error("[ANTI-BUG] Delete failed:", e.message);
+                return;
+            }
+
+            if (config.action === 'kick') {
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n\n${userTag} kicked for crash messages.`,
+                    mentions: [senderId]
+                });
+                await sock.groupParticipantsUpdate(chatId, [senderId], 'remove');
+            } else if (config.action === 'warn') {
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n\n${userTag}, crash messages prohibited!`,
+                    mentions: [senderId]
+                });
+            }
+        } else {
+            const config = getOwnerConfig('antibug_pm') || { enabled: false };
+            if (!config.enabled) return;
+            if (message.key.fromMe || db.isSudo(senderId)) return;
+
+            const botName = getBotName();
+            const senderNumber = senderId.split('@')[0];
+            const fake = createFakeContact(senderId);
+            const ownerNumber = sock.user.id.split(':')[0] + '@s.whatsapp.net';
+
+            await sock.sendMessage(ownerNumber, {
+                text: `*${botName} - BUG BLOCKED (PM)*\n\nFrom: @${senderNumber}\nAction: ${config.action || 'delete'}`,
+                mentions: [senderId]
+            }, { quoted: fake });
+
+            if (config.action === 'kick' || config.action === 'warn') {
+                try {
+                    await sock.updateBlockStatus(senderId, 'block');
+                    await sock.sendMessage(ownerNumber, {
+                        text: `*${botName}*\n@${senderNumber} blocked for sending crash messages in PM.`,
+                        mentions: [senderId]
+                    }, { quoted: fake });
+                } catch (e) {
+                    console.error("[ANTI-BUG PM] Block failed:", e.message);
+                }
+            }
+        }
+    } catch (error) {
+        console.error('Error in handleBugDetection:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    antibugCommand,
+    handleBugDetection
+};

package/davexcore/anti/anticall.js

@@ -0,0 +1,219 @@
+const { getOwnerConfig, setOwnerConfig, parseToggleCommand, parseActionCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const processedCalls = new Map();
+const CALL_COOLDOWN_MS = 30000;
+
+async function isAuthorized(sock, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        if (message.key.fromMe) return true;
+        return db.isSudo(senderId);
+    } catch {
+        return message.key.fromMe;
+    }
+}
+
+async function anticallCommand(sock, chatId, message, args) {
+    const botName = getBotName();
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    
+    if (!await isAuthorized(sock, message)) {
+        return sock.sendMessage(chatId, { 
+            text: `✦ Owner only command` 
+        }, { quoted: fake });
+    }
+
+    const config = getOwnerConfig('anticall') || { enabled: false, mode: 'block', message: 'Calls not allowed!' };
+    const sub = (args || '').trim().toLowerCase();
+
+    if (!sub) {
+        const helpText = `✦ *ANTICALL*
+    
+  Status: ${config.enabled ? 'ON' : 'OFF'}
+  Mode: ${config.mode || 'block'}
+  Message: ${config.message || 'Calls not allowed!'}
+
+  Commands:
+  › on
+  › off
+  › block
+  › decline
+  › both
+  › allow
+  › .setcallmsg <text>
+  › status`;
+        
+        await sock.sendMessage(chatId, { text: helpText }, { quoted: fake });
+        return;
+    }
+
+    let newConfig = { ...config };
+    let responseText = '';
+
+    if (sub === 'status') {
+        const statusText = `✦ *ANTICALL STATUS*
+    
+  Status: ${config.enabled ? 'ACTIVE' : 'INACTIVE'}
+  Mode: ${config.mode || 'block'}
+  Message: ${config.message || 'Calls not allowed!'}`;
+        await sock.sendMessage(chatId, { text: statusText }, { quoted: fake });
+        return;
+    }
+
+    const toggle = parseToggleCommand(sub);
+    if (toggle === 'on') {
+        newConfig.enabled = true;
+        responseText = `✦ Anticall ENABLED\n  Mode: ${newConfig.mode || 'block'}`;
+    } else if (toggle === 'off') {
+        newConfig.enabled = false;
+        responseText = `✦ Anticall DISABLED`;
+    } else {
+        const action = parseActionCommand(sub);
+        if (action === 'block') {
+            newConfig.mode = 'block';
+            newConfig.enabled = true;
+            responseText = `✦ Mode: BLOCK\n  Callers will be blocked`;
+        } else if (action === 'decline') {
+            newConfig.mode = 'decline';
+            newConfig.enabled = true;
+            responseText = `✦ Mode: DECLINE\n  Calls will be declined only`;
+        } else if (sub === 'both') {
+            newConfig.mode = 'both';
+            newConfig.enabled = true;
+            responseText = `✦ Mode: BOTH\n  Declined and blocked`;
+        } else if (action === 'allow') {
+            newConfig.mode = 'allow';
+            newConfig.enabled = false;
+            responseText = `✦ Mode: ALLOW\n  All calls allowed`;
+        } else if (sub.startsWith('msg ') || sub.startsWith('message ')) {
+            const msgText = args.replace(/^(msg|message)\s+/i, '').trim();
+            if (msgText) {
+                newConfig.message = msgText;
+                responseText = `✦ Message set: "${msgText}"`;
+            } else {
+                responseText = `✦ Provide a message`;
+            }
+        } else {
+            responseText = `✦ Invalid command\n  Use: on, off, block, decline, both, allow`;
+        }
+    }
+
+    if (responseText && !responseText.includes('Invalid') && !responseText.includes('Provide')) {
+        setOwnerConfig('anticall', newConfig);
+    }
+
+    await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+}
+
+async function setcallmsgCommand(sock, chatId, message, args) {
+    const botName = getBotName();
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    
+    if (!await isAuthorized(sock, message)) {
+        return sock.sendMessage(chatId, { 
+            text: `✦ Owner only command` 
+        }, { quoted: fake });
+    }
+
+    const msgText = (args || '').trim();
+    
+    if (!msgText) {
+        const config = getOwnerConfig('anticall') || { message: 'Calls not allowed!' };
+        return sock.sendMessage(chatId, { 
+            text: `✦ *SETCALLMSG*
+    
+  Current: ${config.message}
+
+  Use: .setcallmsg <message>` 
+        }, { quoted: fake });
+    }
+
+    const config = getOwnerConfig('anticall') || {};
+    setOwnerConfig('anticall', { ...config, message: msgText });
+    
+    await sock.sendMessage(chatId, { 
+        text: `✦ Message set: "${msgText}"` 
+    }, { quoted: fake });
+}
+
+async function handleIncomingCall(sock, call) {
+    try {
+        const config = getOwnerConfig('anticall');
+        if (!config || !config.enabled || config.mode === 'allow') return;
+        
+        const callKey = call.id || `${call.from}_${Date.now()}`;
+        const now = Date.now();
+        if (processedCalls.has(callKey)) {
+            const lastTime = processedCalls.get(callKey);
+            if (now - lastTime < CALL_COOLDOWN_MS) return;
+        }
+        processedCalls.set(callKey, now);
+        
+        if (processedCalls.size > 50) {
+            for (const [key, time] of processedCalls) {
+                if (now - time > 60000) processedCalls.delete(key);
+            }
+        }
+        
+        const callerId = call.from;
+        const callerNumber = callerId.split('@')[0];
+        const botName = getBotName();
+        const fake = createFakeContact(callerId);
+        
+        try { await sock.rejectCall(call.id, call.from); } catch (e) {}
+        
+        const customMsg = config.message || 'Calls not allowed!';
+        let modeText = '';
+        
+        switch (config.mode) {
+            case 'block':
+                modeText = 'You have been blocked';
+                break;
+            case 'decline':
+                modeText = 'Call declined';
+                break;
+            case 'both':
+                modeText = 'Call declined and blocked';
+                break;
+            default:
+                modeText = 'Call declined';
+        }
+        
+        const responseMsg = `✦ *${botName}*\n\n${customMsg}\n${modeText}`;
+        
+        await sock.sendMessage(callerId, { text: responseMsg }, { quoted: fake });
+        
+        if (config.mode === 'block' || config.mode === 'both') {
+            try {
+                await sock.updateBlockStatus(callerId, 'block');
+            } catch (blockErr) {
+                console.error('Error blocking caller:', blockErr.message);
+            }
+            
+            const ownerNumber = sock.user.id.split(':')[0] + '@s.whatsapp.net';
+            await sock.sendMessage(ownerNumber, {
+                text: `✦ *CALL BLOCKED*\n\nFrom: @${callerNumber}\nAction: ${config.mode.toUpperCase()}`,
+                mentions: [callerId]
+            }, { quoted: fake });
+        }
+        
+    } catch (err) {
+        console.error('Error handling call:', err.message);
+    }
+}
+
+function readState() {
+    const config = getOwnerConfig('anticall') || {};
+    return { enabled: config.enabled || false };
+}
+
+module.exports = { 
+    anticallCommand, 
+    setcallmsgCommand,
+    handleIncomingCall,
+    readState 
+};