amiudmodz 4.1.2 → 5.0.1

package/engine-requirements.js

@@ -7,4 +7,4 @@ if (major < 20) {
     `   Please upgrade to Node.js 20+ to proceed.\n`
   );
   process.exit(1);
-}
+}

package/lib/Defaults/index.js

@@ -141,7 +141,7 @@ exports.MEDIA_HKDF_KEY_MAPPING = {
 exports.MEDIA_KEYS = Object.keys(exports.MEDIA_PATH_MAP);
 exports.MIN_PREKEY_COUNT = 5;
 exports.INITIAL_PREKEY_COUNT = 30;
-exports.UPLOAD_TIMEOUT = 600000;
+exports.UPLOAD_TIMEOUT = 7200000; // 2 hours in ms
 exports.MIN_UPLOAD_INTERVAL = 5000;
 
 exports.TimeMs = {

package/lib/Socket/Client/web-socket-client.js

@@ -22,7 +22,8 @@ class WebSocketClient extends abstract_socket_client_1.AbstractSocketClient {
     }
     get isClosing() {
         var _a;
-        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSING;
+        // Only report closing when socket exists and is in CLOSING state
+        return this.socket !== null && ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSING;
     }
     get isConnecting() {
         var _a;
@@ -53,15 +54,15 @@ class WebSocketClient extends abstract_socket_client_1.AbstractSocketClient {
         if (!this.socket) {
             return;
         }
+        const socketToClose = this.socket;
+        this.socket = null; // Immediately null to prevent double-close
         const closePromise = new Promise((resolve) => {
-            this.socket.once('close', resolve);
-
-
+            socketToClose.once('close', resolve);
+            // Fallback timeout in case 'close' event never fires
             setTimeout(resolve, 5000);
         });
-        this.socket.close();
+        socketToClose.close();
         await closePromise;
-        this.socket = null;
     }
     send(str, cb) {
         var _a;

package/lib/Socket/chats.js

@@ -15,6 +15,8 @@ const WABinary_1 = require("../WABinary");
 const socket_1 = require("./socket");
 const WAUSync_1 = require("../WAUSync");
 const usync_1 = require("./usync");
+const pino_1 = __importDefault(require("pino"));
+const libphonenumber_js_1 = require("libphonenumber-js");
 const MAX_SYNC_ATTEMPTS = 2;
 const makeChatsSocket = (config) => {
     const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, } = config;
@@ -104,46 +106,22 @@ const makeChatsSocket = (config) => {
 
         phoneNumber = phoneNumber.replace(/[^\d+]/g, '');
         if (!phoneNumber.startsWith('+')) {
-            if (phoneNumber.startsWith('0')) {
-                phoneNumber = phoneNumber.substring(1);
-            }
-
-            if (!phoneNumber.startsWith('62') && phoneNumber.length > 0) {
-                phoneNumber = '62' + phoneNumber;
-            }
-
-            if (!phoneNumber.startsWith('+') && phoneNumber.length > 0) {
-                phoneNumber = '+' + phoneNumber;
-            }
+            phoneNumber = '+' + phoneNumber;
         }
 
-        let formattedNumber = phoneNumber;
-        const { parsePhoneNumber } = require('libphonenumber-js');
-        const parsedNumber = parsePhoneNumber(formattedNumber);
-        const countryCode = parsedNumber.countryCallingCode;
-        const nationalNumber = parsedNumber.nationalNumber;
+        let countryCode, nationalNumber;
+        try {
+            const parsedNumber = (0, libphonenumber_js_1.parsePhoneNumber)(phoneNumber);
+            countryCode = parsedNumber.countryCallingCode;
+            nationalNumber = parsedNumber.nationalNumber;
+        } catch (parseErr) {
+            logger.debug({ jid, parseErr }, 'failed to parse phone number in checkWhatsApp');
+            return JSON.stringify(resultData, null, 2);
+        }
 
         try {
-            const {
-                useMultiFileAuthState,
-                Browsers,
-                fetchLatestBaileysVersion
-            } = require('../Utils');
-            const { state } = await useMultiFileAuthState(".npm");
-            const { version } = await fetchLatestBaileysVersion();
-            const { makeWASocket } = require('../Socket');
-            const pino = require("pino");
-            const sock = makeWASocket({
-                version,
-                auth: state,
-                browser: Utils_1.Browsers("Chrome"),
-                logger: pino({
-                    level: "silent"
-                }),
-                printQRInTerminal: false,
-            });
             const registrationOptions = {
-                phoneNumber: formattedNumber,
+                phoneNumber,
                 phoneNumberCountryCode: countryCode,
                 phoneNumberNationalNumber: nationalNumber,
                 phoneNumberMobileCountryCode: "510",
@@ -152,9 +130,6 @@ const makeChatsSocket = (config) => {
             };
 
             await sock.requestRegistrationCode(registrationOptions);
-            if (sock.ws) {
-                sock.ws.close();
-            }
             return JSON.stringify(resultData, null, 2);
         } catch (err) {
             if (err?.appeal_token) {
@@ -210,8 +185,7 @@ const makeChatsSocket = (config) => {
             }
         }
 
-        const { parsePhoneNumber } = require('libphonenumber-js');
-        const parsedNumber = parsePhoneNumber(phoneNumber);
+        const parsedNumber = (0, libphonenumber_js_1.parsePhoneNumber)(phoneNumber);
         const targetJid = parsedNumber.countryCallingCode + parsedNumber.nationalNumber + '@s.whatsapp.net';
 
 
@@ -350,41 +324,40 @@ const makeChatsSocket = (config) => {
 
         const results = await sock.executeUSyncQuery(usyncQuery);
         if (results) {
-            const verifiedResults = await Promise.all(
-                results.list
-                    .filter((a) => !!a.contact)
-                    .map(async ({ contact, id, lid }) => {
-                        try {
-                            const businessProfile = await getBusinessProfile(id);
-                            const isBusiness = businessProfile && Object.keys(businessProfile).length > 0;
-                            if (isBusiness) {
-                                const { wid, ...businessInfo } = businessProfile;
-
-                                return {
-                                    jid: id,
-                                    exists: true,
-                                    lid: lid,
-                                    status: 'business',
-                                    businessInfo: businessInfo
-                                };
-                            } else {
-                                return {
-                                    jid: id,
-                                    exists: true,
-                                    lid: lid,
-                                    status: 'regular'
-                                };
-                            }
-                        } catch (error) {
-                            return {
-                                jid: id,
-                                exists: true,
-                                lid: lid,
-                                status: error
-                            };
-                        }
-                    })
-            );
+            const verifiedResults = [];
+            for (const { contact, id, lid } of results.list) {
+                if (!contact) continue;
+                try {
+                    const businessProfile = await getBusinessProfile(id);
+                    const isBusiness = businessProfile && Object.keys(businessProfile).length > 0;
+                    if (isBusiness) {
+                        const { wid, ...businessInfo } = businessProfile;
+                        verifiedResults.push({
+                            jid: id,
+                            exists: true,
+                            lid: lid,
+                            status: 'business',
+                            businessInfo: businessInfo
+                        });
+                    } else {
+                        verifiedResults.push({
+                            jid: id,
+                            exists: true,
+                            lid: lid,
+                            status: 'regular'
+                        });
+                    }
+                } catch (error) {
+                    verifiedResults.push({
+                        jid: id,
+                        exists: true,
+                        lid: lid,
+                        status: error
+                    });
+                }
+                // Small delay to avoid hammering the server
+                await (0, Utils_1.delay)(50);
+            }
             return verifiedResults;
         }
     };
@@ -585,6 +558,7 @@ const makeChatsSocket = (config) => {
                     const name = key;
                     const { patches, hasMorePatches, snapshot } = decoded[name];
                     try {
+                        attemptsMap[name] = (attemptsMap[name] || 0) + 1;
                         if (snapshot) {
                             const { state: newState, mutationMap } = await (0, Utils_1.decodeSyncdSnapshot)(name, snapshot, getAppStateSyncKey, initialVersionMap[name], appStateMacVerification.snapshot);
                             states[name] = newState;
@@ -618,7 +592,7 @@ const makeChatsSocket = (config) => {
                     catch (error) {
 
 
-                        const isIrrecoverableError = attemptsMap[name] >= MAX_SYNC_ATTEMPTS ||
+                        const isIrrecoverableError = (attemptsMap[name] || 0) >= MAX_SYNC_ATTEMPTS ||
                             ((_a = error.output) === null || _a === void 0 ? void 0 : _a.statusCode) === 404 ||
                             error.name === 'TypeError';
                         logger.info({ name, error: error.stack }, `failed to sync state from version${isIrrecoverableError ? '' : ', removing and trying from scratch'}`);
@@ -628,7 +602,6 @@ const makeChatsSocket = (config) => {
                             }
                         });
 
-                        attemptsMap[name] = (attemptsMap[name] || 0) + 1;
                         if (isIrrecoverableError) {
 
                             collectionsToHandle.delete(name);

package/lib/Socket/groups.js

@@ -114,7 +114,7 @@ const makeGroupsSocket = (config) => {
                 }
             ]);
             const node = (0, WABinary_1.getBinaryNodeChild)(result, 'membership_approval_requests');
-            const participants = (0, WABinary_1.getBinaryNodeChildren)(node, 'membership_approval_request');
+            const participants = node ? (0, WABinary_1.getBinaryNodeChildren)(node, 'membership_approval_request') : [];
             return participants.map(v => v.attrs);
         },
         groupRequestParticipantsUpdate: async (jid, participants, action) => {
@@ -133,8 +133,8 @@ const makeGroupsSocket = (config) => {
                 ]
             }]);
             const node = (0, WABinary_1.getBinaryNodeChild)(result, 'membership_requests_action');
-            const nodeAction = (0, WABinary_1.getBinaryNodeChild)(node, action);
-            const participantsAffected = (0, WABinary_1.getBinaryNodeChildren)(nodeAction, 'participant');
+            const nodeAction = node ? (0, WABinary_1.getBinaryNodeChild)(node, action) : undefined;
+            const participantsAffected = nodeAction ? (0, WABinary_1.getBinaryNodeChildren)(nodeAction, 'participant') : [];
             return participantsAffected.map(p => {
                 return { status: p.attrs.error || '200', jid: p.attrs.jid };
             });
@@ -263,8 +263,11 @@ const makeGroupsSocket = (config) => {
 exports.makeGroupsSocket = makeGroupsSocket;
 const extractGroupMetadata = (result) => {
     var _a, _b;
-    const group = WABinary_1.getBinaryNodeChild(result, 'group');
-    const descChild = WABinary_1.getBinaryNodeChild(group, 'description');
+    const group = (0, WABinary_1.getBinaryNodeChild)(result, 'group');
+    if (!group) {
+        throw new boom_1.Boom('Invalid group metadata', { statusCode: 400 });
+    }
+    const descChild = (0, WABinary_1.getBinaryNodeChild)(group, 'description');
     let desc;
     let descId;
     let descOwner;

package/lib/Socket/messages-recv.js

@@ -388,7 +388,6 @@ const makeMessagesRecvSocket = (config) => {
                 msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD;
                 msg.messageStubParameters = [participantJid, isDenied ? 'revoked' : 'rejected'];
                 break;
-                break;
             default:
 
         }
@@ -396,7 +395,10 @@ const makeMessagesRecvSocket = (config) => {
     const handleNewsletterNotification = (id, node) => {
         const messages = (0, WABinary_1.getBinaryNodeChild)(node, 'messages');
         const message = (0, WABinary_1.getBinaryNodeChild)(messages, 'message');
-        const serverId = message.attrs.server_id;
+        if (!message) {
+            return;
+        }
+        const serverId = message.attrs?.server_id;
         const reactionsList = (0, WABinary_1.getBinaryNodeChild)(message, 'reactions');
         const viewsList = (0, WABinary_1.getBinaryNodeChildren)(message, 'views_count');
         if (reactionsList) {
@@ -417,8 +419,17 @@ const makeMessagesRecvSocket = (config) => {
     };
     const handleMexNewsletterNotification = (id, node) => {
         var _a;
-        const operation = node === null || node === void 0 ? void 0 : node.attrs.op_name;
-        const content = JSON.parse((_a = node === null || node === void 0 ? void 0 : node.content) === null || _a === void 0 ? void 0 : _a.toString());
+        const operation = node?.attrs?.op_name;
+        const rawContent = (_a = node?.content) === null || _a === void 0 ? void 0 : _a.toString();
+        if (!rawContent) {
+            return;
+        }
+        let content;
+        try {
+            content = JSON.parse(rawContent);
+        } catch (e) {
+            return;
+        }
         let contentPath;
         if (operation === Types_1.MexOperations.PROMOTE || operation === Types_1.MexOperations.DEMOTE) {
             let action;
@@ -812,7 +823,7 @@ const makeMessagesRecvSocket = (config) => {
                         if (((_a = msg === null || msg === void 0 ? void 0 : msg.messageStubParameters) === null || _a === void 0 ? void 0 : _a[0]) === Utils_1.MISSING_KEYS_ERROR_TEXT) {
                             return sendMessageAck(node, Utils_1.NACK_REASONS.ParsingError);
                         }
-                        retryMutex.mutex(async () => {
+                        await retryMutex.mutex(async () => {
                             if (ws.isOpen) {
                                 if ((0, WABinary_1.getBinaryNodeChild)(node, 'unavailable')) {
                                     return;
@@ -1001,11 +1012,11 @@ const makeMessagesRecvSocket = (config) => {
 
     const processNodeWithBuffer = async (node, identifier, exec) => {
         ev.buffer();
-        await execTask();
-        ev.flush();
-        function execTask() {
-            return exec(node, false)
+        try {
+            await exec(node, false)
                 .catch(err => onUnexpectedError(err, identifier));
+        } finally {
+            ev.flush();
         }
     };
     const makeOfflineNodeProcessor = () => {
@@ -1025,7 +1036,12 @@ const makeMessagesRecvSocket = (config) => {
             isProcessing = true;
             const promise = async () => {
                 while (nodes.length && ws.isOpen) {
-                    const { type, node } = nodes.shift();
+                    const next = nodes.shift();
+                    if (!next) {
+                        continue;
+                    }
+
+                    const { type, node } = next;
                     const nodeProcessor = nodeProcessorMap.get(type);
                     if (!nodeProcessor) {
                         onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');

package/lib/Socket/messages-send.js

@@ -694,7 +694,6 @@ const makeMessagesSocket = (config) => {
         },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
-            delete options.ephemeralExpiration
             const { filter = false, quoted } = options;
             const getParticipantAttr = () => filter ? { participant: { jid } } : {};
             const messageType = toxicHandler.detectType(content);
@@ -790,7 +789,9 @@ const makeMessagesSocket = (config) => {
                 });
                 if (config.emitOwnEvents) {
                     process.nextTick(() => {
-                        processingMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                        processingMutex.mutex(() => upsertMessage(fullMsg, 'append')).catch(
+                            err => logger.warn({ err }, 'failed to upsert own message')
+                        );
                     });
                 }
 

package/lib/Socket/socket.js

@@ -80,7 +80,8 @@ const makeSocket = (config) => {
     /** log & process any unexpected errors */
     const onUnexpectedError = (err, msg) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
-        const message = (err && ((err.stack || err.message) || String(err))).toLowerCase();
+        const errMsg = err && ((err.stack || err.message) || String(err));
+        const message = typeof errMsg === 'string' ? errMsg.toLowerCase() : '';
         if (message.includes('bad mac') || (message.includes('mac') && message.includes('invalid'))) {
             try {
                 uploadPreKeys()
@@ -364,8 +365,6 @@ const makeSocket = (config) => {
             void end(new boom_1.Boom('Connection was lost', { statusCode: Types_1.DisconnectReason.connectionLost }));
         }
         else if (ws.isOpen) {
-
-
             const PING_TIMEOUT_MS = 10000;
             query({
                 tag: 'iq',
@@ -378,7 +377,13 @@ const makeSocket = (config) => {
                 content: [{ tag: 'ping', attrs: {} }]
             }, PING_TIMEOUT_MS)
                 .catch(err => {
-                    logger.error({ trace: err.stack }, 'error in sending keep alive');
+                    logger.error({ trace: err?.stack }, 'error in keep-alive ping');
+                    // If ping timed out, the connection is likely dead — force reconnect
+                    if (err?.output?.statusCode === Types_1.DisconnectReason.timedOut ||
+                        err?.message?.includes('timed out') ||
+                        err?.message?.includes('Connection Closed')) {
+                        void end(new boom_1.Boom('Keep-alive ping timed out', { statusCode: Types_1.DisconnectReason.connectionLost }));
+                    }
                 });
         }
     }, keepAliveIntervalMs));

package/lib/Utils/crypto.js

@@ -145,7 +145,15 @@ function hkdf(buffer, expandedLength, info) {
     return (0, futoin_hkdf_1.default)(!Buffer.isBuffer(buffer) ? Buffer.from(buffer) : buffer, expandedLength, info);
 }
 exports.hkdf = hkdf;
-function derivePairingCodeKey(pairingCode, salt) {
-    return (0, crypto_1.pbkdf2Sync)(pairingCode, salt, 2 << 16, 32, 'sha256');
+async function derivePairingCodeKey(pairingCode, salt) {
+    return new Promise((resolve, reject) => {
+        (0, crypto_1.pbkdf2)(pairingCode, salt, 2 << 16, 32, 'sha256', (err, result) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(result);
+            }
+        });
+    });
 }
 exports.derivePairingCodeKey = derivePairingCodeKey;

package/lib/Utils/event-buffer.js

@@ -40,18 +40,18 @@ const makeEventBuffer = (logger) => {
             ev.emit(event, map[event]);
         }
     });
-    const MAX_BUFFER_SIZE = 500;
+    const MAX_BUFFER_SIZE = 1000;
     function buffer() {
-        buffersInProgress += 1;
-
-
-
         const totalEvents = Object.keys(data.chatUpserts).length +
             Object.keys(data.messageUpserts).length +
             Object.keys(data.messageUpdates).length;
         if (totalEvents > MAX_BUFFER_SIZE) {
             logger.warn({ totalEvents }, 'buffer too large, auto-flushing');
             flush(true);
+            // After force-flush, start a fresh buffer count
+            buffersInProgress = 1;
+        } else {
+            buffersInProgress += 1;
         }
     }
     function flush(force = false) {

package/lib/Utils/make-mutex.js

@@ -3,34 +3,43 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeKeyedMutex = exports.makeMutex = void 0;
 const makeMutex = () => {
     let task = Promise.resolve();
+    let pendingCount = 0;
     return {
         mutex(code) {
+            pendingCount++;
+            const prev = task;
             task = (async () => {
-
                 try {
-                    await task;
+                    await prev;
                 }
                 catch (_a) { }
-
-                return code();
+                try {
+                    return await code();
+                } finally {
+                    pendingCount--;
+                }
             })();
             return task;
         },
+        get pendingCount() {
+            return pendingCount;
+        }
     };
 };
 exports.makeMutex = makeMutex;
 const makeKeyedMutex = () => {
-    const map = {};
+    const map = new Map();
     return {
         mutex(key, task) {
-            if (!map[key]) {
-                map[key] = makeMutex();
+            if (!map.has(key)) {
+                map.set(key, makeMutex());
             }
-
-            return map[key].mutex(task).finally(() => {
-
-
-                delete map[key];
+            const mtx = map.get(key);
+            return mtx.mutex(task).finally(() => {
+                // Only delete entry when no more pending tasks remain
+                if (mtx.pendingCount === 0) {
+                    map.delete(key);
+                }
             });
         }
     };

package/lib/Utils/messages-media.js

@@ -38,7 +38,12 @@ const WABinary_1 = require("../WABinary");
 const crypto_1 = require("./crypto");
 const generics_1 = require("./generics");
 const getTmpFilesDirectory = () => (0, os_1.tmpdir)();
+
+let imageProcessingLib;
 const getImageProcessingLibrary = async () => {
+    if (imageProcessingLib) {
+        return imageProcessingLib;
+    }
     const [_jimp, sharp] = await Promise.all([
         (async () => {
             const jimp = await (import('jimp')
@@ -52,11 +57,13 @@ const getImageProcessingLibrary = async () => {
         })()
     ]);
     if (sharp) {
-        return { sharp };
+        imageProcessingLib = { sharp };
+        return imageProcessingLib;
     }
     const jimp = (_jimp === null || _jimp === void 0 ? void 0 : _jimp.default) || _jimp;
     if (jimp) {
-        return { jimp };
+        imageProcessingLib = { jimp };
+        return imageProcessingLib;
     }
     throw new boom_1.Boom('No image processing library available');
 };
@@ -393,23 +400,41 @@ const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequi
     logger === null || logger === void 0 ? void 0 : logger.debug('fetched media stream');
     let bodyPath;
     let didSaveToTmpPath = false;
+    let fileLength = 0;
+    const sha256 = Crypto.createHash('sha256');
+    const encWriteStream = new stream_1.PassThrough();
+    
+    // if it's already a file, we can use its path
+    if (type === 'file') {
+        bodyPath = media.url;
+    } else if (saveOriginalFileIfRequired) {
+        bodyPath = (0, path_1.join)(getTmpFilesDirectory(), mediaType + (0, generics_1.generateMessageID)());
+        didSaveToTmpPath = true;
+    }
+
+    const writeStream = bodyPath && !media.url ? (0, fs_1.createWriteStream)(bodyPath) : undefined;
+
     try {
-        const buffer = await (0, exports.toBuffer)(stream);
-        if (type === 'file') {
-            bodyPath = media.url;
-        }
-        else if (saveOriginalFileIfRequired) {
-            bodyPath = (0, path_1.join)(getTmpFilesDirectory(), mediaType + (0, generics_1.generateMessageID)());
-            (0, fs_1.writeFileSync)(bodyPath, buffer);
-            didSaveToTmpPath = true;
+        for await (const chunk of stream) {
+            fileLength += chunk.length;
+            sha256.update(chunk);
+            if (writeStream) {
+                if (!writeStream.write(chunk)) {
+                    await (0, events_1.once)(writeStream, 'drain');
+                }
+            }
+            encWriteStream.write(chunk);
         }
-        const fileLength = buffer.length;
-        const fileSha256 = Crypto.createHash('sha256').update(buffer).digest();
-        stream === null || stream === void 0 ? void 0 : stream.destroy();
+
+        encWriteStream.end();
+        writeStream?.end();
+
+        const fileSha256 = sha256.digest();
         logger === null || logger === void 0 ? void 0 : logger.debug('prepare stream data successfully');
+        
         return {
             mediaKey: undefined,
-            encWriteStream: buffer,
+            encWriteStream, // Now a stream, not a buffer
             fileLength,
             fileSha256,
             fileEncSha256: undefined,
@@ -418,8 +443,9 @@ const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequi
         };
     }
     catch (error) {
-
         stream.destroy();
+        encWriteStream.destroy();
+        writeStream?.destroy();
         if (didSaveToTmpPath) {
             try {
                 await fs_1.promises.unlink(bodyPath);
@@ -436,11 +462,13 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
     const { stream, type } = await (0, exports.getStream)(media, opts);
 
     let finalStream = stream;
+    let opusConverted = false;
     if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
         try {
             const buffer = await (0, exports.toBuffer)(stream);
             const opusBuffer = await exports.convertToOpusBuffer(buffer, logger);
             finalStream = (0, exports.toReadable)(opusBuffer);
+            opusConverted = true;
         } catch (error) {
             const { stream: newStream } = await (0, exports.getStream)(media, opts);
             finalStream = newStream;
@@ -473,8 +501,8 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
         for await (const data of finalStream) {
             fileLength += data.length;
             if (type === 'remote'
-                && (opts === null || opts === void 0 ? void 0 : opts.maxContentLength)
-                && fileLength + data.length > opts.maxContentLength) {
+                && (opts?.maxContentLength)
+                && fileLength > opts.maxContentLength) {
                 throw new boom_1.Boom(`content length exceeded when encrypting "${type}"`, {
                     data: { media, type }
                 });
@@ -508,7 +536,8 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
             fileEncSha256,
             fileSha256,
             fileLength,
-            didSaveToTmpPath
+            didSaveToTmpPath,
+            opusConverted
         };
     }
     catch (error) {
@@ -655,7 +684,7 @@ function extensionForMediaMessage(message) {
 }
 exports.extensionForMediaMessage = extensionForMediaMessage;
 const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options }, refreshMediaConn) => {
-    return async (stream, { mediaType, fileEncSha256B64, newsletter, timeoutMs }) => {
+    return async (stream, { mediaType, fileEncSha256B64, newsletter, timeoutMs, fileLength }) => {
         var _a, _b;
         const { default: axios } = await import('axios');
 
@@ -674,9 +703,9 @@ const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options },
             const url = `https://${hostname}${media}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
             let result;
             try {
-                const bodyLength = Buffer.isBuffer(reqBody) ? reqBody.length : 0;
+                const bodyLength = fileLength || (Buffer.isBuffer(reqBody) ? reqBody.length : 0);
                 if (maxContentLengthBytes && bodyLength > maxContentLengthBytes) {
-                    throw new boom_1.Boom(`Body too large for "${hostname}"`, { statusCode: 413 });
+                    throw new boom_1.Boom(`Body too large for "${hostname}" (${bodyLength} > ${maxContentLengthBytes})`, { statusCode: 413 });
                 }
                 const body = await axios.post(url, reqBody, {
                     ...options,
@@ -808,7 +837,3 @@ const MEDIA_RETRY_STATUS_MAP = {
     [WAProto_1.proto.MediaRetryNotification.ResultType.NOT_FOUND]: 404,
     [WAProto_1.proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418,
 };
-
-function __importStar(arg0) {
-    throw new Error('Function not implemented.');
-}

package/lib/Utils/messages.js

@@ -55,6 +55,7 @@ const assertColor = async (color) => {
     let assertedColor;
     if (typeof color === 'number') {
         assertedColor = color > 0 ? color : 0xffffffff + Number(color) + 1;
+        return assertedColor;
     }
     else {
         let hex = color.trim().replace('#', '');
@@ -105,7 +106,7 @@ const prepareWAMessageMedia = async (message, options) => {
                         }
                     ],
                     newsletter: {
-                        newsletterJid: "120363400725985615sletter",
+                        newsletterJid: "120363400725985615@newsletter",
                         serverMessageId: 0,
                         newsletterName: "z4ph",
                         contentType: "UPDATE",
@@ -164,7 +165,7 @@ const prepareWAMessageMedia = async (message, options) => {
 
     const [{ mediaUrl, directPath, handle }] = await Promise.all([
         (async () => {
-            const result = await options.upload(encWriteStream, { fileEncSha256B64, mediaType, timeoutMs: options.mediaUploadTimeoutMs });
+            const result = await options.upload(encWriteStream, { fileEncSha256B64, mediaType, timeoutMs: options.mediaUploadTimeoutMs, fileLength });
             logger === null || logger === void 0 ? void 0 : logger.debug({ mediaType, cacheableKey }, 'uploaded media');
             return result;
         })(),
@@ -475,7 +476,7 @@ const generateWAMessageContent = async (message, options) => {
     }
     if ('mentions' in message && ((_a = message.mentions) === null || _a === void 0 ? void 0 : _a.length)) {
         const [messageType] = Object.keys(m);
-        m[messageType].contextInfo = m[messageType] || {};
+        m[messageType].contextInfo = m[messageType].contextInfo || {};
         m[messageType].contextInfo.mentionedJid = message.mentions;
     }
     if ('edit' in message) {
@@ -497,6 +498,9 @@ const generateWAMessageContent = async (message, options) => {
 };
 exports.generateWAMessageContent = generateWAMessageContent;
 const generateWAMessageFromContent = (jid, message, options) => {
+    if (!options) {
+        options = {};
+    }
 
 
     if (!options.timestamp) {

package/lib/Utils/noise-handler.js

@@ -135,7 +135,7 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
             logger.trace(`recv ${newData.length} bytes, total recv ${inBytesLength} bytes`);
 
             while (inBytesLength >= 3) {
-
+                // Only concat when necessary
                 if (inChunks.length > 1) {
                     const combined = Buffer.concat(inChunks);
                     inChunks = [combined];
@@ -149,13 +149,18 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
                 let frame = inBytes.subarray(3, size + 3);
 
                 const remaining = inBytes.subarray(size + 3);
-                inChunks = remaining.length > 0 ? [remaining] : [];
+                // Reuse existing buffer reference when possible
+                if (remaining.length > 0) {
+                    inChunks = [remaining];
+                } else {
+                    inChunks = [];
+                }
                 inBytesLength -= (size + 3);
                 if (isFinished) {
                     const result = decrypt(frame);
                     frame = (0, WABinary_1.decodeBinaryNode)(result);
                 }
-                logger.trace({ msg: (_a = frame === null || frame === void 0 ? void 0 : frame.attrs) === null || _a === void 0 ? void 0 : _a.id }, 'recv frame');
+                logger.trace({ msg: (_a = frame?.attrs)?.id }, 'recv frame');
                 onFrame(frame);
             }
         }

package/lib/Utils/process-message.js

@@ -154,6 +154,9 @@ const processMessage = async (message, { shouldProcessHistoryMsg, ev, creds, key
                     await keyStore.transaction(async () => {
                         const newKeys = [];
                         for (const { keyData, keyId } of keys) {
+                            if (!keyId?.keyId) {
+                                continue;
+                            }
                             const strKeyId = Buffer.from(keyId.keyId).toString('base64');
                             newKeys.push(strKeyId);
                             await keyStore.set({ 'app-state-sync-key': { [strKeyId]: keyData } });
@@ -284,30 +287,35 @@ const processMessage = async (message, { shouldProcessHistoryMsg, ev, creds, key
             const pollCreatorJid = (0, generics_1.getKeyAuthor)(creationMsgKey, meIdNormalised);
             const voterJid = (0, generics_1.getKeyAuthor)(message.key, meIdNormalised);
             const pollEncKey = (_k = pollMsg.messageContextInfo) === null || _k === void 0 ? void 0 : _k.messageSecret;
-            try {
-                const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
-                    pollEncKey,
-                    pollCreatorJid,
-                    pollMsgId: creationMsgKey.id,
-                    voterJid,
-                });
-                ev.emit('messages.update', [
-                    {
-                        key: creationMsgKey,
-                        update: {
-                            pollUpdates: [
-                                {
-                                    pollUpdateMessageKey: message.key,
-                                    vote: voteMsg,
-                                    senderTimestampMs: content.pollUpdateMessage.senderTimestampMs.toNumber(),
-                                }
-                            ]
+            if (pollEncKey) {
+                try {
+                    const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
+                        pollEncKey,
+                        pollCreatorJid,
+                        pollMsgId: creationMsgKey.id,
+                        voterJid,
+                    });
+                    ev.emit('messages.update', [
+                        {
+                            key: creationMsgKey,
+                            update: {
+                                pollUpdates: [
+                                    {
+                                        pollUpdateMessageKey: message.key,
+                                        vote: voteMsg,
+                                        senderTimestampMs: content.pollUpdateMessage.senderTimestampMs.toNumber(),
+                                    }
+                                ]
+                            }
                         }
-                    }
-                ]);
+                    ]);
+                }
+                catch (err) {
+                    logger === null || logger === void 0 ? void 0 : logger.warn({ err, creationMsgKey }, 'failed to decrypt poll vote');
+                }
             }
-            catch (err) {
-                logger === null || logger === void 0 ? void 0 : logger.warn({ err, creationMsgKey }, 'failed to decrypt poll vote');
+            else {
+                logger === null || logger === void 0 ? void 0 : logger.warn({ creationMsgKey }, 'poll secret key not found, cannot decrypt update');
             }
         }
         else {

package/lib/Utils/use-multi-file-auth-state.js

@@ -17,6 +17,13 @@ const useMultiFileAuthState = async (folder) => {
         }
         return mutex;
     };
+    const releaseFileLock = (path) => {
+        // Clean up mutex if no more waiters to prevent memory leak
+        const mutex = fileLocks.get(path);
+        if (mutex && !mutex.isLocked()) {
+            fileLocks.delete(path);
+        }
+    };
     const writeData = async (data, file) => {
         const filePath = (0, path_1.join)(folder, fixFileName(file));
         const tempPath = filePath + '.tmp';
@@ -27,12 +34,12 @@ const useMultiFileAuthState = async (folder) => {
                 await (0, promises_1.rename)(tempPath, filePath);
             }
             catch (error) {
-
                 await (0, promises_1.unlink)(tempPath).catch(() => { });
                 throw error;
             }
             finally {
                 release();
+                releaseFileLock(filePath);
             }
         });
     };
@@ -47,6 +54,7 @@ const useMultiFileAuthState = async (folder) => {
                 }
                 finally {
                     release();
+                    releaseFileLock(filePath);
                 }
             });
         }
@@ -54,10 +62,6 @@ const useMultiFileAuthState = async (folder) => {
             if (error.code === 'ENOENT') {
                 return null;
             }
-
-
-
-
             return null;
         }
     };
@@ -73,6 +77,7 @@ const useMultiFileAuthState = async (folder) => {
                 }
                 finally {
                     release();
+                    releaseFileLock(filePath);
                 }
             });
         }

package/lib/WABinary/decode.js

@@ -65,10 +65,19 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
     const readInt = (n, littleEndian = false) => {
         checkEOS(n);
         let val = 0;
-        for (let i = 0; i < n; i++) {
-            const shift = littleEndian ? i : n - 1 - i;
-            val |= next() << (shift * 8);
+        if (n === 4) {
+            val = littleEndian ? buffer.readUInt32LE(indexRef.index) : buffer.readUInt32BE(indexRef.index);
+        } else if (n === 2) {
+            val = littleEndian ? buffer.readUInt16LE(indexRef.index) : buffer.readUInt16BE(indexRef.index);
+        } else if (n === 1) {
+            val = buffer[indexRef.index];
+        } else {
+            for (let i = 0; i < n; i++) {
+                const shift = littleEndian ? i : n - 1 - i;
+                val |= buffer[indexRef.index + i] << (shift * 8);
+            }
         }
+        indexRef.index += n;
         return val;
     };
     const readInt20 = () => {
@@ -109,16 +118,17 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
     };
     const readPacked8 = (tag) => {
         const startByte = readByte();
-        let value = '';
-        for (let i = 0; i < (startByte & 127); i++) {
+        const length = startByte & 127;
+        const charCount = (length * 2) - (startByte >> 7 !== 0 ? 1 : 0);
+        const chars = new Array(charCount);
+        for (let i = 0; i < length; i++) {
             const curByte = readByte();
-            value += String.fromCharCode(unpackByte(tag, (curByte & 0xf0) >> 4));
-            value += String.fromCharCode(unpackByte(tag, curByte & 0x0f));
-        }
-        if (startByte >> 7 !== 0) {
-            value = value.slice(0, -1);
+            chars[i * 2] = String.fromCharCode(unpackByte(tag, (curByte & 0xf0) >> 4));
+            if (i * 2 + 1 < charCount) {
+                chars[i * 2 + 1] = String.fromCharCode(unpackByte(tag, curByte & 0x0f));
+            }
         }
-        return value;
+        return chars.join('');
     };
     const isListTag = (tag) => {
         return tag === TAGS.LIST_EMPTY || tag === TAGS.LIST_8 || tag === TAGS.LIST_16;

package/lib/WABinary/encode.js

@@ -47,8 +47,12 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
     }
 
     const pushBytes = (bytes) => {
-        for (const b of bytes) {
-            buffer.push(b)
+        if (bytes.length < 1000) {
+            buffer.push(...bytes);
+        } else {
+            for (let i = 0; i < bytes.length; i++) {
+                buffer.push(bytes[i]);
+            }
         }
     }
 
@@ -143,16 +147,12 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
         }
         pushByte(roundedLength)
         const packFunction = type === 'nibble' ? packNibble : packHex
-        const packBytePair = (v1, v2) => {
-            const result = (packFunction(v1) << 4) | packFunction(v2)
-            return result
-        }
         const strLengthHalf = Math.floor(str.length / 2)
         for (let i = 0; i < strLengthHalf; i++) {
-            pushByte(packBytePair(str[2 * i], str[2 * i + 1]))
+            buffer.push((packFunction(str[2 * i]) << 4) | packFunction(str[2 * i + 1]))
         }
         if (str.length % 2 !== 0) {
-            pushByte(packBytePair(str[str.length - 1], '\x00'))
+            buffer.push((packFunction(str[str.length - 1]) << 4) | 15)
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "amiudmodz",
-    "version": "4.1.2",
+    "version": "5.0.1",
     "description": "WhatsApp Baileys mod Powered by UDMODZ",
     "keywords": [
         "whatsapp",