jsdecryptor 4.0.3

package/davexcore/group/ban.js

@@ -0,0 +1,63 @@
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function banCommand(sock, chatId, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    if (!message.key.fromMe && !db.isSudo(senderId)) {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nOwner only command!`
+        }, { quoted: fake });
+        return;
+    }
+
+    let userToBan;
+    
+    if (message.message?.extendedTextMessage?.contextInfo?.mentionedJid?.length > 0) {
+        userToBan = message.message.extendedTextMessage.contextInfo.mentionedJid[0];
+    } else if (message.message?.extendedTextMessage?.contextInfo?.participant) {
+        userToBan = message.message.extendedTextMessage.contextInfo.participant;
+    }
+    
+    if (!userToBan) {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nMention or reply to a user to ban!`
+        }, { quoted: fake });
+        return;
+    }
+
+    try {
+        const botId = sock.user?.id?.split(':')[0] + '@s.whatsapp.net';
+        if (userToBan === botId || userToBan === sock.user?.id) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nCannot ban the bot!`
+            }, { quoted: fake });
+            return;
+        }
+    } catch {}
+
+    try {
+        if (!db.isBanned(userToBan)) {
+            db.addBannedUser(userToBan);
+            
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\n\n@${userToBan.split('@')[0]} has been banned!`,
+                mentions: [userToBan]
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\n\n@${userToBan.split('@')[0]} is already banned!`,
+                mentions: [userToBan]
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in ban command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nFailed to ban user!`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = banCommand;

package/davexcore/group/blockUnblock.js

@@ -0,0 +1,177 @@
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+function resolveTarget(message) {
+    const contextInfo = message.message?.extendedTextMessage?.contextInfo;
+    const quotedParticipant = contextInfo?.participant;
+    const mentionedJids = contextInfo?.mentionedJid || [];
+    const text = message.message?.conversation ||
+                 message.message?.extendedTextMessage?.text || '';
+    const argNumber = text.split(/\s+/).slice(1).join('').replace(/[^0-9]/g, '');
+
+    if (quotedParticipant) return quotedParticipant;
+    if (mentionedJids.length > 0) return mentionedJids[0];
+    if (argNumber.length >= 7) return `${argNumber}@s.whatsapp.net`;
+    return null;
+}
+
+async function blockCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    try {
+        if (!message.key.fromMe) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | Owner only command.`
+            }, { quoted: fake });
+        }
+
+        const userToBlock = resolveTarget(message);
+
+        if (!userToBlock) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | How to block:\n\n• Reply to a message → .block\n• Mention: .block @user\n• By number: .block 254712345678`
+            }, { quoted: fake });
+        }
+
+        const botId = (sock.user?.id || '').split(':')[0];
+        if (userToBlock.includes(botId)) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | Cannot block the bot itself!`
+            }, { quoted: fake });
+        }
+
+        await sock.updateBlockStatus(userToBlock, 'block');
+        const num = userToBlock.split('@')[0];
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ✅ Blocked +${num}`,
+            mentions: [userToBlock]
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('blockCommand error:', error.message);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Block failed — reply to the user's message or mention them.`
+        }, { quoted: fake }).catch(() => {});
+    }
+}
+
+async function unblockCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    try {
+        if (!message.key.fromMe) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | Owner only command.`
+            }, { quoted: fake });
+        }
+
+        const userToUnblock = resolveTarget(message);
+
+        if (!userToUnblock) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | How to unblock:\n\n• Mention: .unblock @user\n• By number: .unblock 254712345678`
+            }, { quoted: fake });
+        }
+
+        await sock.updateBlockStatus(userToUnblock, 'unblock');
+        const num = userToUnblock.split('@')[0];
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ✅ Unblocked +${num}`,
+            mentions: [userToUnblock]
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('unblockCommand error:', error.message);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Unblock failed.`
+        }, { quoted: fake }).catch(() => {});
+    }
+}
+
+async function blocklistCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    try {
+        if (!message.key.fromMe) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | Owner only command.`
+            }, { quoted: fake });
+        }
+
+        const blockedContacts = await sock.fetchBlocklist().catch(() => []);
+        if (!blockedContacts.length) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | No blocked contacts.`
+            }, { quoted: fake });
+        }
+
+        const total = blockedContacts.length;
+        const listText = blockedContacts
+            .slice(0, 30)
+            .map((jid, i) => `${i + 1}. +${jid.split('@')[0]}`)
+            .join('\n');
+
+        let text = `✦ *${botName}* | Blocklist\n\n📋 Total: *${total}*\n\n${listText}`;
+        if (total > 30) text += `\n\n... and ${total - 30} more`;
+
+        await sock.sendMessage(chatId, { text }, { quoted: fake });
+    } catch (error) {
+        console.error('blocklistCommand error:', error.message);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Failed to fetch blocklist.`
+        }, { quoted: fake }).catch(() => {});
+    }
+}
+
+async function unblockallCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    try {
+        if (!message.key.fromMe) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | Owner only command.`
+            }, { quoted: fake });
+        }
+
+        const blockedContacts = await sock.fetchBlocklist().catch(() => []);
+        if (!blockedContacts.length) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | No blocked contacts to unblock.`
+            }, { quoted: fake });
+        }
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | 🔄 Unblocking ${blockedContacts.length} contacts...`
+        }, { quoted: fake });
+
+        let successCount = 0;
+        for (const jid of blockedContacts) {
+            try {
+                await sock.updateBlockStatus(jid, 'unblock');
+                successCount++;
+                if (successCount % 10 === 0) {
+                    await sock.sendMessage(chatId, {
+                        text: `✦ *${botName}* | Progress: ${successCount}/${blockedContacts.length}...`
+                    }, { quoted: fake });
+                }
+                await delay(500);
+            } catch { }
+        }
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ✅ Unblocked ${successCount}/${blockedContacts.length} contacts.`
+        }, { quoted: fake });
+    } catch (error) {
+        console.error('unblockallCommand error:', error.message);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Failed to unblock all.`
+        }, { quoted: fake }).catch(() => {});
+    }
+}
+
+module.exports = {
+    blockCommand,
+    unblockCommand,
+    blocklistCommand,
+    unblockallCommand
+};

package/davexcore/group/clear.js

@@ -0,0 +1,196 @@
+async function clearCommand(sock, chatId, isGroup = false, numberOfMessages = 50) {
+    try {
+        // Send initial notification
+        const notification = await sock.sendMessage(chatId, { 
+            text: `🗑️ Clearing ${numberOfMessages} messages...` 
+        });
+
+        let messagesDeleted = 0;
+        
+        if (isGroup) {
+            // For group chats - clear bot messages and command messages
+            messagesDeleted = await clearGroupMessages(sock, chatId, numberOfMessages);
+        } else {
+            // For private chats - clear recent messages
+            messagesDeleted = await clearPrivateMessages(sock, chatId, numberOfMessages);
+        }
+
+        // Update notification with result
+        await sock.sendMessage(chatId, { 
+            text: `✅ Successfully cleared ${messagesDeleted} messages!`,
+            edit: notification.key 
+        });
+
+        // Auto-delete the success message after 3 seconds
+        setTimeout(async () => {
+            try {
+                await sock.sendMessage(chatId, { 
+                    delete: notification.key 
+                });
+            } catch (error) {
+                console.log('Failed to auto-delete notification:', error);
+            }
+        }, 3000);
+
+    } catch (error) {
+        console.error('Error clearing messages:', error);
+        await sock.sendMessage(chatId, { 
+            text: '❌ An error occurred while clearing messages.' 
+        });
+    }
+}
+
+// Helper function for group messages
+async function clearGroupMessages(sock, chatId, limit) {
+    let deletedCount = 0;
+    
+    try {
+        // Get recent messages in the group
+        const messages = await sock.fetchMessagesFromWA(chatId, limit);
+        
+        for (const message of messages) {
+            try {
+                // Delete messages sent by the bot or command messages
+                if (message.key.fromMe || 
+                    (message.message?.conversation && 
+                     message.message.conversation.startsWith('!clear'))) {
+                    
+                    await sock.sendMessage(chatId, { 
+                        delete: message.key 
+                    });
+                    deletedCount++;
+                    
+                    // Add small delay to avoid rate limiting
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            } catch (msgError) {
+                console.log(`Failed to delete message: ${message.key.id}`);
+            }
+        }
+    } catch (error) {
+        console.error('Error in clearGroupMessages:', error);
+    }
+    
+    return deletedCount;
+}
+
+// Helper function for private messages
+async function clearPrivateMessages(sock, chatId, limit) {
+    let deletedCount = 0;
+    
+    try {
+        // Get recent messages in private chat
+        const messages = await sock.fetchMessagesFromWA(chatId, limit);
+        
+        for (const message of messages) {
+            try {
+                // In private chats, we can delete our own messages
+                if (message.key.fromMe) {
+                    await sock.sendMessage(chatId, { 
+                        delete: message.key 
+                    });
+                    deletedCount++;
+                    
+                    // Add small delay to avoid rate limiting
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            } catch (msgError) {
+                console.log(`Failed to delete message: ${message.key.id}`);
+            }
+        }
+    } catch (error) {
+        console.error('Error in clearPrivateMessages:', error);
+    }
+    
+    return deletedCount;
+}
+
+// Alternative function to clear all messages (more aggressive)
+async function clearAllMessages(sock, chatId, isGroup = false) {
+    try {
+        const notification = await sock.sendMessage(chatId, { 
+            text: '🧹 Clearing all clearable messages...' 
+        });
+
+        let totalDeleted = 0;
+        const batchSize = 50;
+        let hasMoreMessages = true;
+
+        while (hasMoreMessages && totalDeleted < 1000) { // Safety limit
+            const messages = await sock.fetchMessagesFromWA(chatId, batchSize);
+            
+            if (messages.length === 0) {
+                hasMoreMessages = false;
+                break;
+            }
+
+            let batchDeleted = 0;
+            for (const message of messages) {
+                try {
+                    if (message.key.fromMe) {
+                        await sock.sendMessage(chatId, { 
+                            delete: message.key 
+                        });
+                        batchDeleted++;
+                        totalDeleted++;
+
+                        // Rate limiting
+                        await new Promise(resolve => setTimeout(resolve, 50));
+                    }
+                } catch (error) {
+                    console.log(`Failed to delete message: ${message.key.id}`);
+                }
+            }
+
+            // If we didn't delete any messages in this batch, stop
+            if (batchDeleted === 0) {
+                hasMoreMessages = false;
+            }
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: `✅ Cleared ${totalDeleted} messages total!`,
+            edit: notification.key 
+        });
+
+        setTimeout(async () => {
+            try {
+                await sock.sendMessage(chatId, { 
+                    delete: notification.key 
+                });
+            } catch (error) {
+                console.log('Failed to auto-delete notification');
+            }
+        }, 3000);
+
+    } catch (error) {
+        console.error('Error in clearAllMessages:', error);
+        await sock.sendMessage(chatId, { 
+            text: '❌ Error clearing all messages.' 
+        });
+    }
+}
+
+// Enhanced command handler with parameters
+async function handleClearCommand(sock, chatId, message, args) {
+    const isGroup = chatId.endsWith('@g.us');
+    
+    // Parse arguments
+    if (args.includes('all')) {
+        return await clearAllMessages(sock, chatId, isGroup);
+    }
+    
+    const countMatch = args.find(arg => !isNaN(parseInt(arg)));
+    const messageCount = countMatch ? parseInt(countMatch) : 50;
+    
+    // Limit for safety
+    const safeCount = Math.min(messageCount, 200);
+    
+    return await clearCommand(sock, chatId, isGroup, safeCount);
+}
+
+module.exports = { 
+    clearCommand, 
+    clearAllMessages, 
+    handleClearCommand 
+};

package/davexcore/group/creategroup.js

@@ -0,0 +1,43 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function creategroupCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    
+    if (!message.key.fromMe) {
+        return sock.sendMessage(chatId, { 
+            text: 'Owner only command'
+        }, { quoted: fake });
+    }
+
+    const text = message.message?.conversation || 
+                 message.message?.extendedTextMessage?.text || '';
+    
+    const groupName = text.split(' ').slice(1).join(' ').trim();
+    
+    if (!groupName) {
+        return sock.sendMessage(chatId, { 
+            text: 'Provide group name'
+        }, { quoted: fake });
+    }
+
+    try {
+        const createdGroup = await sock.groupCreate(groupName, []);
+        const code = await sock.groupInviteCode(createdGroup.id);
+        const link = `https://chat.whatsapp.com/${code}`;
+
+        const info = `Group created\nName: ${createdGroup.subject}\nID: ${createdGroup.id}\nOwner: @${createdGroup.owner.split("@")[0]}\nLink: ${link}`;
+
+        await sock.sendMessage(chatId, {
+            text: info,
+            mentions: [createdGroup.owner]
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('Creategroup Error:', error);
+        await sock.sendMessage(chatId, { 
+            text: 'Failed to create group'
+        }, { quoted: fake });
+    }
+}
+
+module.exports = creategroupCommand;

package/davexcore/group/demote.js

@@ -0,0 +1,115 @@
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function demoteCommand(sock, chatId, mentionedJids, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    try {
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nGroup command only!`
+            }, { quoted: fake });
+            return;
+        }
+
+        const adminStatus = await isAdmin(sock, chatId, senderId);
+
+        if (!adminStatus.isBotAdmin) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nBot needs admin!`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!adminStatus.isSenderAdmin && !message.key.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAdmin only command!`
+            }, { quoted: fake });
+            return;
+        }
+
+        let userToDemote = [];
+
+        if (mentionedJids && mentionedJids.length > 0) {
+            userToDemote = mentionedJids;
+        } else if (message.message?.extendedTextMessage?.contextInfo?.participant) {
+            userToDemote = [message.message.extendedTextMessage.contextInfo.participant];
+        }
+
+        if (userToDemote.length === 0) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nMention or reply to demote!`
+            }, { quoted: fake });
+            return;
+        }
+
+        const botJid = sock.user?.id?.split(':')[0];
+
+        const filteredUsersToDemote = userToDemote.filter(jid => {
+            const cleanJid = jid.split(':')[0];
+            return cleanJid !== botJid;
+        });
+
+        if (filteredUsersToDemote.length === 0) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nCannot demote the bot!`
+            }, { quoted: fake });
+            return;
+        }
+
+        await sock.groupParticipantsUpdate(chatId, filteredUsersToDemote, "demote");
+
+        const usernames = filteredUsersToDemote.map(jid => `@${jid.split('@')[0]}`).join(', ');
+
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\n\nDemoted: ${usernames}`,
+            mentions: filteredUsersToDemote
+        }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in demote command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nFailed to demote.`
+        }, { quoted: fake });
+    }
+}
+
+async function handleDemotionEvent(sock, groupId, participants, author) {
+    try {
+        if (!Array.isArray(participants) || participants.length === 0) return;
+
+        const botJid = sock.user?.id?.split(':')[0];
+
+        const filteredParticipants = participants.filter(jid => {
+            const jidString = typeof jid === 'string' ? jid : (jid.id || jid.toString());
+            const cleanJid = jidString.split(':')[0];
+            return cleanJid !== botJid;
+        });
+
+        if (filteredParticipants.length === 0) return;
+
+        const isBotAction = author && (author === botJid || author.includes(botJid));
+        if (!isBotAction) return;
+
+        const botName = getBotName();
+        const demotedUsernames = filteredParticipants.map(jid => {
+            const jidString = typeof jid === 'string' ? jid : (jid.id || jid.toString());
+            return `@${jidString.split('@')[0]}`;
+        }).join(', ');
+
+        const mentionList = filteredParticipants.map(jid => {
+            return typeof jid === 'string' ? jid : (jid.id || jid.toString());
+        });
+
+        await sock.sendMessage(groupId, {
+            text: `*${botName}*\n\nDemoted: ${demotedUsernames}`,
+            mentions: mentionList
+        });
+    } catch (error) {
+        console.error('Error handling demotion event:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = { demoteCommand, handleDemotionEvent };

package/davexcore/group/disappear.js

@@ -0,0 +1,67 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const DURATIONS = {
+    'off':  0,
+    '0':    0,
+    '1d':   86400,
+    '24h':  86400,
+    '7d':   604800,
+    '1w':   604800,
+    '90d':  7776000,
+    '3m':   7776000,
+    '3mo':  7776000,
+};
+
+const LABELS = {
+    0:       'OFF',
+    86400:   '24 Hours',
+    604800:  '7 Days',
+    7776000: '90 Days',
+};
+
+async function disappearCommand(sock, chatId, message, args) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    const isGroup = chatId.endsWith('@g.us');
+
+    if (!args[0]) {
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\n╭─ Disappearing Messages ─╮\n│\n│ Available durations:\n│ • off / 0\n│ • 1d / 24h\n│ • 7d / 1w\n│ • 90d / 3m\n│\n│ Example: .disappear 7d\n╰─────────────────────────╯`
+        }, { quoted: fake });
+        return;
+    }
+
+    const key = args[0].toLowerCase();
+    if (!(key in DURATIONS)) {
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\n❌ Unknown duration: *${args[0]}*\nOptions: off, 1d, 7d, 90d`
+        }, { quoted: fake });
+        return;
+    }
+
+    const seconds = DURATIONS[key];
+
+    try {
+        await sock.sendMessage(chatId, { react: { text: '⏳', key: message.key } });
+
+        if (isGroup) {
+            await sock.groupToggleEphemeral(chatId, seconds);
+        } else {
+            await sock.sendMessage(chatId, {
+                disappearingMessagesInChat: seconds
+            });
+        }
+
+        const label = LABELS[seconds] || 'Custom';
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\n✅ Disappearing messages: *${label}*`
+        }, { quoted: fake });
+    } catch (e) {
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\n❌ Failed: ${e.message}`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = disappearCommand;