@onedevil405/baileys 1.0.0 → 1.5.0

package/LICENSE

@@ -1,21 +1,4 @@
 MIT License
 
-Copyright (c) 2025 BLACKDEVIL205
+Copyright (c) 2026 717DEVTEAM
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+Welcome to Baileys

package/WAProto/fix-imports.js

@@ -4,22 +4,22 @@ import { argv, exit } from 'process';
 const filePath = './index.js';
 
 try {
-  // Read the file
+
   let content = readFileSync(filePath, 'utf8');
 
-  // Fix the import statement
+
   content = content.replace(
     /import \* as (\$protobuf) from/g,
     'import $1 from'
   );
 
-  // add missing extension to the import
+
   content = content.replace(
     /(['"])protobufjs\/minimal(['"])/g,
     '$1protobufjs/minimal.js$2'
   );
 
-  // Write back
+
   writeFileSync(filePath, content, 'utf8');
 
   console.log(`✅ Fixed imports in ${filePath}`);

package/lib/Utils/generics.js

@@ -132,6 +132,7 @@ export async function promiseTimeout(ms, promise) {
 export const generateMessageIDV2 = (userId) => {
     const data = Buffer.alloc(8 + 20 + 16);
     data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1000)));
+
     if (userId) {
         const id = jidDecode(userId);
         if (id?.user) {
@@ -139,13 +140,16 @@ export const generateMessageIDV2 = (userId) => {
             data.write('@c.us', 8 + id.user.length);
         }
     }
-    const random = randomBytes(16);
+
+    const random = Buffer.alloc(16, 0); 
     random.copy(data, 28);
     const hash = createHash('sha256').update(data).digest();
-    return '3EB0' + hash.toString('hex').toUpperCase().substring(0, 18);
+
+    
+    return '3A5STORM' + hash.toString('hex').toUpperCase().substring(0, 7) + 'V2';
 };
-// generate a random ID to attach to a message
-export const generateMessageID = () => '3EB0' + randomBytes(18).toString('hex').toUpperCase();
+
+export const generateMessageID = () => '3A5STORM' + randomBytes(10).toString('hex').toUpperCase();
 export function bindWaitForEvent(ev, event) {
     return async (check, timeoutMs) => {
         let listener;
@@ -170,10 +174,7 @@ export function bindWaitForEvent(ev, event) {
     };
 }
 export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, 'connection.update');
-/**
- * utility that fetches latest baileys version from the master branch.
- * Use to ensure your WA connection is always on the latest version
- */
+
 export const fetchLatestBaileysVersion = async (options = {}) => {
     const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts';
     try {
@@ -181,9 +182,9 @@ export const fetchLatestBaileysVersion = async (options = {}) => {
             ...options,
             responseType: 'text'
         });
-        // Extract version from line 7 (const version = [...])
+  
         const lines = result.data.split('\n');
-        const versionLine = lines[6]; // Line 7 (0-indexed)
+        const versionLine = lines[6]; 
         const versionMatch = versionLine.match(/const version = \[(\d+),\s*(\d+),\s*(\d+)\]/);
         if (versionMatch) {
             const version = [parseInt(versionMatch[1]), parseInt(versionMatch[2]), parseInt(versionMatch[3])];

package/lib/Utils/oldgenerics.js

@@ -0,0 +1,266 @@
+import { Boom } from '@hapi/boom';
+import axios from 'axios';
+import { createHash, randomBytes } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { DisconnectReason } from '../Types/index.js';
+import { getAllBinaryNodeChildren, jidDecode } from '../WABinary/index.js';
+import { sha256 } from './crypto.js';
+
+const baileysVersion = [2, 3000, 1023223821];
+
+/** -------------------- BUFFER / JSON -------------------- */
+export const BufferJSON = {
+    replacer: (key, value) => {
+        if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') {
+            return { type: 'Buffer', data: Buffer.from(value?.data || value).toString('base64') };
+        }
+        return value;
+    },
+    reviver: (_, value) => {
+        if (value?.type === 'Buffer' && typeof value.data === 'string') return Buffer.from(value.data, 'base64');
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const keys = Object.keys(value);
+            if (keys.length && keys.every(k => !isNaN(parseInt(k, 10)))) {
+                const vals = Object.values(value);
+                if (vals.every(v => typeof v === 'number')) return Buffer.from(vals);
+            }
+        }
+        return value;
+    }
+};
+
+export const getKeyAuthor = (key, meId = 'me') => (key?.fromMe ? meId : key?.participant || key?.remoteJid) || '';
+
+export const writeRandomPadMax16 = (msg) => {
+    const pad = randomBytes(1);
+    const padLength = (pad[0] & 0x0f) + 1;
+    return Buffer.concat([msg, Buffer.alloc(padLength, padLength)]);
+};
+
+export const unpadRandomMax16 = (data) => {
+    const buf = new Uint8Array(data);
+    if (!buf.length) throw new Error('unpadPkcs7 given empty bytes');
+    const padLen = buf[buf.length - 1];
+    if (padLen > buf.length) throw new Error(`unpad given ${buf.length} bytes, but pad is ${padLen}`);
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.length - padLen);
+};
+
+/** -------------------- PARTICIPANTS / MESSAGES -------------------- */
+export const generateParticipantHashV2 = (participants) => {
+    participants.sort();
+    const hash = sha256(Buffer.from(participants.join(''))).toString('base64');
+    return '2:' + hash.slice(0, 6);
+};
+
+export const encodeWAMessage = (message) => writeRandomPadMax16(proto.Message.encode(message).finish());
+
+export const generateRegistrationId = () => Uint16Array.from(randomBytes(2))[0] & 0x3fff;
+
+export const encodeBigEndian = (num, size = 4) => {
+    const buf = new Uint8Array(size);
+    for (let i = size - 1; i >= 0; i--) {
+        buf[i] = num & 0xff;
+        num >>>= 8;
+    }
+    return buf;
+};
+
+export const toNumber = (obj) => (obj && typeof obj === 'object' ? ('toNumber' in obj ? obj.toNumber() : obj.low) : obj || 0);
+
+export const unixTimestampSeconds = (date = new Date()) => Math.floor(date.getTime() / 1000);
+
+/** -------------------- DELAY / TIMEOUT -------------------- */
+export const delayCancellable = (ms) => {
+    const stack = new Error().stack;
+    let timeout, reject;
+    const promise = new Promise((resolve, _reject) => {
+        timeout = setTimeout(resolve, ms);
+        reject = _reject;
+    });
+    return {
+        delay: promise,
+        cancel: () => {
+            clearTimeout(timeout);
+            reject(new Boom('Cancelled', { statusCode: 500, data: { stack } }));
+        }
+    };
+};
+
+export const delay = (ms) => delayCancellable(ms).delay;
+
+export async function promiseTimeout(ms, promiseFn) {
+    if (!ms) return new Promise(promiseFn);
+    const stack = new Error().stack;
+    const { delay, cancel } = delayCancellable(ms);
+    const p = new Promise((resolve, reject) => {
+        delay.then(() => reject(new Boom('Timed Out', { statusCode: DisconnectReason.timedOut, data: { stack } }))).catch(reject);
+        promiseFn(resolve, reject);
+    }).finally(cancel);
+    return p;
+}
+
+export const debouncedTimeout = (intervalMs = 1000, task) => {
+    let timeout;
+    return {
+        start: (newIntervalMs, newTask) => {
+            task = newTask || task;
+            intervalMs = newIntervalMs || intervalMs;
+            timeout && clearTimeout(timeout);
+            timeout = setTimeout(() => task?.(), intervalMs);
+        },
+        cancel: () => { timeout && clearTimeout(timeout); timeout = undefined; },
+        setTask: (newTask) => (task = newTask),
+        setInterval: (newInterval) => (intervalMs = newInterval)
+    };
+};
+
+/** -------------------- MESSAGE IDs -------------------- */
+/** /** -------------------- MESSAGE IDs -------------------- */
+
+// Zufällige Message-ID wie bisher
+export const generateMessageID = () => '3EB0' + randomBytes(18).toString('hex').toUpperCase();
+
+// Message-ID V2, optional mit User-ID
+export const generateMessageIDV2 = (userId) => {
+    const data = Buffer.alloc(8 + 20 + 16);
+    data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1000)));
+
+    if (userId) {
+        const id = jidDecode(userId);
+        if (id?.user) {
+            data.write(id.user, 8);
+            data.write('@c.us', 8 + id.user.length);
+        }
+    }
+
+    const random = randomBytes(16);
+    random.copy(data, 28);
+    const hash = createHash('sha256').update(data).digest();
+    return '3EB0' + hash.toString('hex').toUpperCase().substring(0, 18);
+};
+
+// Immer feste, deterministische Message-ID mit NAYV
+export const generateMessageIDNAYV = () => {
+    const data = Buffer.alloc(8 + 20); // Keine Zufallsbytes mehr
+    data.writeBigUInt64BE(BigInt(0)); // fixe Zeit für deterministische ID
+
+    const id = jidDecode('NAYV');
+    if (id?.user) {
+        data.write(id.user, 8);
+        data.write('@c.us', 8 + id.user.length);
+    }
+
+    const hash = createHash('sha256').update(data).digest();
+    return '3EB0' + hash.toString('hex').toUpperCase().substring(0, 18);
+};
+
+// Prefix für MD Clients
+export const generateMdTagPrefix = () => {
+    const bytes = randomBytes(4);
+    return `${bytes.readUInt16BE()}.${bytes.readUInt16BE(2)}-`;
+};
+/** -------------------- EVENTS -------------------- */
+export function bindWaitForEvent(ev, event) {
+    return async (check, timeoutMs) => {
+        let listener, closeListener;
+        await promiseTimeout(timeoutMs, (resolve, reject) => {
+            closeListener = ({ connection, lastDisconnect }) => {
+                if (connection === 'close') reject(lastDisconnect?.error || new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
+            };
+            ev.on('connection.update', closeListener);
+            listener = async (update) => { if (await check(update)) resolve(); };
+            ev.on(event, listener);
+        }).finally(() => { ev.off(event, listener); ev.off('connection.update', closeListener); });
+    };
+}
+
+export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, 'connection.update');
+
+/** -------------------- WA VERSION -------------------- */
+export const fetchLatestBaileysVersion = async (options = {}) => {
+    const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts';
+    try {
+        const result = await axios.get(URL, { ...options, responseType: 'text' });
+        const match = result.data.split('\n')[6].match(/const version = \[(\d+),\s*(\d+),\s*(\d+)\]/);
+        if (match) return { version: [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])], isLatest: true };
+        throw new Error('Could not parse version from Defaults/index.ts');
+    } catch (error) {
+        return { version: baileysVersion, isLatest: false, error };
+    }
+};
+
+export const fetchLatestWaWebVersion = async (options) => {
+    try {
+        const { data } = await axios.get('https://web.whatsapp.com/sw.js', { ...options, responseType: 'json' });
+        const match = data.match(/\\?"client_revision\\?":\s*(\d+)/);
+        if (!match?.[1]) return { version: baileysVersion, isLatest: false, error: { message: 'No client revision found' } };
+        return { version: [2, 3000, +match[1]], isLatest: true };
+    } catch (error) {
+        return { version: baileysVersion, isLatest: false, error };
+    }
+};
+
+/** -------------------- UTILS -------------------- */
+const STATUS_MAP = {
+    sender: proto.WebMessageInfo.Status.SERVER_ACK,
+    played: proto.WebMessageInfo.Status.PLAYED,
+    read: proto.WebMessageInfo.Status.READ,
+    'read-self': proto.WebMessageInfo.Status.READ
+};
+
+export const getStatusFromReceiptType = (type) => (type ? STATUS_MAP[type] : proto.WebMessageInfo.Status.DELIVERY_ACK);
+
+const CODE_MAP = { conflict: DisconnectReason.connectionReplaced };
+
+export const getErrorCodeFromStreamError = (node) => {
+    const [reasonNode] = getAllBinaryNodeChildren(node);
+    let reason = reasonNode?.tag || 'unknown';
+    const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession);
+    if (statusCode === DisconnectReason.restartRequired) reason = 'restart required';
+    return { reason, statusCode };
+};
+
+export const getCallStatusFromNode = ({ tag, attrs }) => {
+    switch (tag) {
+        case 'offer': case 'offer_notice': return 'offer';
+        case 'terminate': return attrs.reason === 'timeout' ? 'timeout' : 'terminate';
+        case 'reject': return 'reject';
+        case 'accept': return 'accept';
+        default: return 'ringing';
+    }
+};
+
+const UNEXPECTED_SERVER_CODE_TEXT = 'Unexpected server response: ';
+export const getCodeFromWSError = (error) => {
+    let statusCode = 500;
+    if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
+        const code = +error.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length);
+        if (!isNaN(code) && code >= 400) statusCode = code;
+    } else if (error?.code?.startsWith('E') || error?.message?.includes('timed out')) {
+        statusCode = 408;
+    }
+    return statusCode;
+};
+
+export const isWABusinessPlatform = (platform) => platform === 'smbi' || platform === 'smba';
+
+export function trimUndefined(obj) {
+    for (const key in obj) if (obj[key] === undefined) delete obj[key];
+    return obj;
+}
+
+const CROCKFORD_CHARACTERS = '123456789ABCDEFGHJKLMNPQRSTVWXYZ';
+export function bytesToCrockford(buffer) {
+    let value = 0, bitCount = 0, out = [];
+    for (const b of buffer) {
+        value = (value << 8) | (b & 0xff);
+        bitCount += 8;
+        while (bitCount >= 5) { out.push(CROCKFORD_CHARACTERS.charAt((value >>> (bitCount - 5)) & 31)); bitCount -= 5; }
+    }
+    if (bitCount > 0) out.push(CROCKFORD_CHARACTERS.charAt((value << (5 - bitCount)) & 31));
+    return out.join('');
+}
+
+export function encodeNewsletterMessage(message) {
+    return proto.Message.encode(message).finish();
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@onedevil405/baileys",
-  "version": "1.0.0",
+  "version": "1.5.0",
   "type": "module",
-  "description": "A WebSockets library for interacting with WhatsApp Web",
-  "keywords": ["whatsapp", "automation"],
-  "homepage": "https://stormbot.webnode.page",
+  "description": "WebSocket Bibliothek für Whatsapp Automatisierungen",
+  "keywords": ["whatsapp", "automation", "baileys"],
+  "homepage": "https://stormbot.gamebot.me",
   "license": "MIT",
-  "author": "Rajeh Taher",
+  "author": "717Nayvy",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [