@periskope/baileys 6.7.18-17-2 → 6.7.18-17-3

package/lib/Signal/Group/group_cipher.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupCipher = void 0;
+/* @ts-ignore */
 const crypto_1 = require("libsignal/src/crypto");
 const sender_key_message_1 = require("./sender-key-message");
 class GroupCipher {
@@ -30,13 +31,9 @@ class GroupCipher {
             throw new Error('No SenderKeyRecord found for decryption');
         }
         const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
-        let senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
-        // Fallback: try to get the latest sender key state if specific keyId not found
+        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
         if (!senderKeyState) {
-            senderKeyState = record.getSenderKeyState();
-            if (!senderKeyState) {
-                throw new Error('No session found to decrypt message');
-            }
+            throw new Error('No session found to decrypt message');
         }
         senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
         const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());

package/lib/Signal/libsignal.d.ts

@@ -1,3 +1,3 @@
-import { SignalAuthState } from '../Types';
-import { SignalRepository } from '../Types/Signal';
+import type { SignalAuthState } from '../Types';
+import type { SignalRepository } from '../Types/Signal';
 export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;

package/lib/Signal/libsignal.js

@@ -42,12 +42,13 @@ const sender_key_record_1 = require("./Group/sender-key-record");
 const Group_1 = require("./Group");
 function makeLibSignalRepository(auth) {
     const storage = signalStorage(auth);
+    const parsedKeys = auth.keys;
     return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
             // Use transaction to ensure atomicity
-            return auth.keys.transaction(async () => {
+            return parsedKeys.transaction(async () => {
                 return cipher.decrypt(msg);
             });
         },
@@ -59,7 +60,11 @@ function makeLibSignalRepository(auth) {
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
             const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
             const senderNameStr = senderName.toString();
-            return auth.keys.transaction(async () => {
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+            }
+            return parsedKeys.transaction(async () => {
                 const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
                 if (!senderKey) {
                     await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
@@ -70,8 +75,8 @@ function makeLibSignalRepository(auth) {
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
-            // Use transaction to ensure atomicityAdd commentMore actions
-            return auth.keys.transaction(async () => {
+            // Use transaction to ensure atomicity
+            return parsedKeys.transaction(async () => {
                 let result;
                 switch (type) {
                     case 'pkmsg':
@@ -80,6 +85,8 @@ function makeLibSignalRepository(auth) {
                     case 'msg':
                         result = await session.decryptWhisperMessage(ciphertext);
                         break;
+                    default:
+                        throw new Error(`Unknown message type: ${type}`);
                 }
                 return result;
             });
@@ -87,8 +94,8 @@ function makeLibSignalRepository(auth) {
         async encryptMessage({ jid, data }) {
             const addr = jidToSignalProtocolAddress(jid);
             const cipher = new libsignal.SessionCipher(storage, addr);
-            // Use transaction to ensure atomicityAdd commentMore actions
-            return auth.keys.transaction(async () => {
+            // Use transaction to ensure atomicity
+            return parsedKeys.transaction(async () => {
                 const { type: sigType, body } = await cipher.encrypt(data);
                 const type = sigType === 3 ? 'pkmsg' : 'msg';
                 return { type, ciphertext: Buffer.from(body, 'binary') };
@@ -98,8 +105,7 @@ function makeLibSignalRepository(auth) {
             const senderName = jidToSignalSenderKeyName(group, meId);
             const builder = new Group_1.GroupSessionBuilder(storage);
             const senderNameStr = senderName.toString();
-            // Use transaction to ensure atomicity
-            return auth.keys.transaction(async () => {
+            return parsedKeys.transaction(async () => {
                 const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
                 if (!senderKey) {
                     await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
@@ -115,8 +121,7 @@ function makeLibSignalRepository(auth) {
         },
         async injectE2ESession({ jid, session }) {
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            // Use transaction to ensure atomicity
-            return auth.keys.transaction(async () => {
+            return parsedKeys.transaction(async () => {
                 await cipher.initOutgoing(session);
             });
         },
@@ -140,6 +145,7 @@ function signalStorage({ creds, keys }) {
                 return libsignal.SessionRecord.deserialize(sess);
             }
         },
+        // TODO: Replace with libsignal.SessionRecord when type exports are added to libsignal
         storeSession: async (id, session) => {
             await keys.set({ session: { [id]: session.serialize() } });
         },

package/lib/Utils/auth-utils.d.ts

@@ -1,5 +1,5 @@
 import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types';
-import { ILogger } from './logger';
+import type { ILogger } from './logger';
 /**
  * Adds caching capability to a SignalKeyStore
  * @param store the store to add caching to

package/lib/Utils/auth-utils.js

@@ -71,11 +71,9 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
             });
         },
         async clear() {
-            return cacheMutex.runExclusive(async () => {
-                var _a;
-                cache.flushAll();
-                await ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store));
-            });
+            var _a;
+            cache.flushAll();
+            await ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store));
         }
     };
 }
@@ -113,8 +111,12 @@ async function handlePreKeyOperations(data, keyType, transactionCache, mutations
         }
         // Process updates first (no validation needed)
         for (const keyId of updateKeys) {
-            transactionCache[keyType][keyId] = keyData[keyId];
-            mutations[keyType][keyId] = keyData[keyId];
+            if (transactionCache[keyType]) {
+                transactionCache[keyType][keyId] = keyData[keyId];
+            }
+            if (mutations[keyType]) {
+                mutations[keyType][keyId] = keyData[keyId];
+            }
         }
         // Process deletions with validation
         if (deletionKeys.length === 0)
@@ -122,9 +124,12 @@ async function handlePreKeyOperations(data, keyType, transactionCache, mutations
         if (isInTransaction) {
             // In transaction, only allow deletion if key exists in cache
             for (const keyId of deletionKeys) {
-                if (transactionCache[keyType][keyId]) {
+                if (transactionCache[keyType]) {
                     transactionCache[keyType][keyId] = null;
-                    mutations[keyType][keyId] = null;
+                    if (mutations[keyType]) {
+                        // Mark for deletion in mutations
+                        mutations[keyType][keyId] = null;
+                    }
                 }
                 else {
                     logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`);
@@ -138,8 +143,10 @@ async function handlePreKeyOperations(data, keyType, transactionCache, mutations
         const existingKeys = await state.get(keyType, deletionKeys);
         for (const keyId of deletionKeys) {
             if (existingKeys[keyId]) {
-                transactionCache[keyType][keyId] = null;
-                mutations[keyType][keyId] = null;
+                if (transactionCache[keyType])
+                    transactionCache[keyType][keyId] = null;
+                if (mutations[keyType])
+                    mutations[keyType][keyId] = null;
             }
             else {
                 logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
@@ -170,7 +177,8 @@ async function processPreKeyDeletions(data, keyType, state, logger) {
                 const existingKeys = await state.get(keyType, [keyId]);
                 if (!existingKeys[keyId]) {
                     logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
-                    delete data[keyType][keyId];
+                    if (data[keyType])
+                        delete data[keyType][keyId];
                 }
             }
         }
@@ -208,30 +216,6 @@ async function withMutexes(keyTypes, getKeyTypeMutex, fn) {
         }
     }
 }
-/**
- * Attempts to commit transaction with retry mechanism
- * Uses async-mutex's withTimeout for better timeout handling
- */
-async function commitWithRetry(mutations, state, getKeyTypeMutex, maxRetries, delayMs, logger) {
-    let tries = maxRetries;
-    while (tries > 0) {
-        tries -= 1;
-        try {
-            // Use basic withMutexes - withTimeout is for decorating mutexes, not functions
-            await withMutexes(Object.keys(mutations), getKeyTypeMutex, async () => {
-                await state.set(mutations);
-                logger.trace('committed transaction');
-            });
-            break;
-        }
-        catch (error) {
-            logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
-            if (tries > 0) {
-                await (0, generics_1.delay)(delayMs);
-            }
-        }
-    }
-}
 /**
  * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
  * this allows batch read & write operations & improves the performance of the lib
@@ -240,17 +224,52 @@ async function commitWithRetry(mutations, state, getKeyTypeMutex, maxRetries, de
  * @returns SignalKeyStore with transaction capability
  */
 const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
-    // Mutex for each key type (session, pre-key, etc.)
-    const keyTypeMutexes = new Map();
-    // Per-sender-key-name mutexes for fine-grained serialization
-    const senderKeyMutexes = new Map();
-    // Global transaction mutex
-    const transactionMutex = new async_mutex_1.Mutex();
     // number of queries made to the DB during the transaction
     // only there for logging purposes
     let dbQueriesInTransaction = 0;
     let transactionCache = {};
     let mutations = {};
+    // Mutex for each key type (session, pre-key, etc.)
+    const keyTypeMutexes = new Map();
+    // Per-sender-key-name mutexes for fine-grained serialization
+    const senderKeyMutexes = new Map();
+    // Track last usage time for sender key mutexes (for cleanup)
+    const senderKeyMutexLastUsed = new Map();
+    // Mutex expiration time: 1 hour in milliseconds
+    const SENDER_KEY_MUTEX_EXPIRY_MS = 60 * 60 * 1000;
+    // Cleanup interval: every 30 minutes
+    const CLEANUP_INTERVAL_MS = 30 * 60 * 1000;
+    // Cleanup timer
+    let cleanupTimer = null;
+    // Start cleanup timer if not already running
+    function startCleanupTimer() {
+        if (!cleanupTimer) {
+            cleanupTimer = setInterval(() => {
+                cleanupExpiredSenderKeyMutexes();
+            }, CLEANUP_INTERVAL_MS);
+        }
+    }
+    // Clean up expired sender key mutexes
+    function cleanupExpiredSenderKeyMutexes() {
+        const now = Date.now();
+        const expiredKeys = [];
+        for (const [senderKeyName, lastUsed] of senderKeyMutexLastUsed.entries()) {
+            if (now - lastUsed > SENDER_KEY_MUTEX_EXPIRY_MS) {
+                const mutex = senderKeyMutexes.get(senderKeyName);
+                // Only remove if mutex is not currently being used
+                if (mutex && !mutex.isLocked()) {
+                    expiredKeys.push(senderKeyName);
+                }
+            }
+        }
+        if (expiredKeys.length > 0) {
+            for (const key of expiredKeys) {
+                senderKeyMutexes.delete(key);
+                senderKeyMutexLastUsed.delete(key);
+            }
+            logger.info({ expiredKeys: expiredKeys.length }, 'cleaned up expired sender key mutexes');
+        }
+    }
     let transactionsInProgress = 0;
     // Get or create a mutex for a specific key type
     function getKeyTypeMutex(type) {
@@ -267,9 +286,14 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
         let mutex = senderKeyMutexes.get(senderKeyName);
         if (!mutex) {
             mutex = new async_mutex_1.Mutex();
+            if (senderKeyMutexes.size === 0) {
+                startCleanupTimer();
+            }
             senderKeyMutexes.set(senderKeyName, mutex);
             logger.info({ senderKeyName }, 'created new sender key mutex');
         }
+        // Update last used time
+        senderKeyMutexLastUsed.set(senderKeyName, Date.now());
         return mutex;
     }
     // Sender key operations with proper mutex sequencing
@@ -341,10 +365,11 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
         set: async (data) => {
             if (isInTransaction()) {
                 logger.trace({ types: Object.keys(data) }, 'caching in transaction');
-                for (const key in data) {
+                for (const key_ in data) {
+                    const key = key_;
                     transactionCache[key] = transactionCache[key] || {};
                     // Special handling for pre-keys and signed-pre-keys
-                    if (key === 'pre-key' || key === 'signed-pre-key') {
+                    if (key === 'pre-key') {
                         await handlePreKeyOperations(data, key, transactionCache, mutations, logger, true);
                     }
                     else {
@@ -363,6 +388,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                     for (const senderKeyName of senderKeyNames) {
                         await queueSenderKeyOperation(senderKeyName, async () => {
                             // Create data subset for this specific sender key
+                            // @ts-ignore
                             const senderKeyData = {
                                 'sender-key': {
                                     [senderKeyName]: data['sender-key'][senderKeyName]
@@ -380,8 +406,9 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                     if (Object.keys(nonSenderKeyData).length > 0) {
                         await withMutexes(Object.keys(nonSenderKeyData), getKeyTypeMutex, async () => {
                             // Process pre-keys and signed-pre-keys separately with specialized mutexes
-                            for (const keyType in nonSenderKeyData) {
-                                if (keyType === 'pre-key' || keyType === 'signed-pre-key') {
+                            for (const key_ in nonSenderKeyData) {
+                                const keyType = key_;
+                                if (keyType === 'pre-key') {
                                     await processPreKeyDeletions(nonSenderKeyData, keyType, state, logger);
                                 }
                             }
@@ -394,8 +421,9 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                     // No sender keys - use original logic
                     await withMutexes(Object.keys(data), getKeyTypeMutex, async () => {
                         // Process pre-keys and signed-pre-keys separately with specialized mutexes
-                        for (const keyType in data) {
-                            if (keyType === 'pre-key' || keyType === 'signed-pre-key') {
+                        for (const key_ in data) {
+                            const keyType = key_;
+                            if (keyType === 'pre-key') {
                                 await processPreKeyDeletions(data, keyType, state, logger);
                             }
                         }
@@ -406,49 +434,49 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             }
         },
         isInTransaction,
-        ...(state.clear ? { clear: state.clear } : {}),
         async transaction(work) {
-            return transactionMutex.acquire().then(async (releaseTxMutex) => {
-                let result;
-                try {
-                    transactionsInProgress += 1;
-                    if (transactionsInProgress === 1) {
-                        logger.trace('entering transaction');
-                    }
-                    // Release the transaction mutex now that we've updated the counter
-                    // This allows other transactions to start preparing
-                    releaseTxMutex();
-                    try {
-                        result = await work();
-                        // commit if this is the outermost transaction
-                        if (transactionsInProgress === 1) {
-                            const hasMutations = Object.keys(mutations).length > 0;
-                            if (hasMutations) {
-                                logger.trace('committing transaction');
-                                await commitWithRetry(mutations, state, getKeyTypeMutex, maxCommitRetries, delayBetweenTriesMs, logger);
-                                logger.trace({ dbQueriesInTransaction }, 'transaction completed');
+            let result;
+            transactionsInProgress += 1;
+            if (transactionsInProgress === 1) {
+                logger.trace('entering transaction');
+            }
+            try {
+                result = await work();
+                // commit if this is the outermost transaction
+                if (transactionsInProgress === 1) {
+                    if (Object.keys(mutations).length) {
+                        logger.trace('committing transaction');
+                        // retry mechanism to ensure we've some recovery
+                        // in case a transaction fails in the first attempt
+                        let tries = maxCommitRetries;
+                        while (tries) {
+                            tries -= 1;
+                            //eslint-disable-next-line max-depth
+                            try {
+                                await state.set(mutations);
+                                logger.trace({ dbQueriesInTransaction }, 'committed transaction');
+                                break;
                             }
-                            else {
-                                logger.trace('no mutations in transaction');
+                            catch (error) {
+                                logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
+                                await (0, generics_1.delay)(delayBetweenTriesMs);
                             }
                         }
                     }
-                    finally {
-                        transactionsInProgress -= 1;
-                        if (transactionsInProgress === 0) {
-                            transactionCache = {};
-                            mutations = {};
-                            dbQueriesInTransaction = 0;
-                        }
+                    else {
+                        logger.trace('no mutations in transaction');
                     }
-                    return result;
                 }
-                catch (error) {
-                    // If we haven't released the transaction mutex yet, release it
-                    releaseTxMutex();
-                    throw error;
+            }
+            finally {
+                transactionsInProgress -= 1;
+                if (transactionsInProgress === 0) {
+                    transactionCache = {};
+                    mutations = {};
+                    dbQueriesInTransaction = 0;
                 }
-            });
+            }
+            return result;
         }
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@periskope/baileys",
-  "version": "6.7.18-17-2",
+  "version": "6.7.18-17-3",
   "description": "WhatsApp API",
   "keywords": [
     "periskope",