@periskope/baileys 6.7.18-17-4 → 6.7.18-17-7

package/lib/Signal/Group/group_cipher.d.ts

@@ -8,6 +8,7 @@ export declare class GroupCipher {
     private readonly senderKeyStore;
     private readonly senderKeyName;
     constructor(senderKeyStore: SenderKeyStore, senderKeyName: SenderKeyName);
+    private queueJob;
     encrypt(paddedPlaintext: Uint8Array | string): Promise<Uint8Array>;
     decrypt(senderKeyMessageBytes: Uint8Array): Promise<Uint8Array>;
     private getSenderKey;

package/lib/Signal/Group/group_cipher.js

@@ -1,45 +1,55 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupCipher = void 0;
-/* @ts-ignore */
 const crypto_1 = require("libsignal/src/crypto");
+const queue_job_1 = __importDefault(require("./queue-job"));
 const sender_key_message_1 = require("./sender-key-message");
 class GroupCipher {
     constructor(senderKeyStore, senderKeyName) {
         this.senderKeyStore = senderKeyStore;
         this.senderKeyName = senderKeyName;
     }
+    queueJob(awaitable) {
+        return (0, queue_job_1.default)(this.senderKeyName.toString(), awaitable);
+    }
     async encrypt(paddedPlaintext) {
-        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
-        if (!record) {
-            throw new Error('No SenderKeyRecord found for encryption');
-        }
-        const senderKeyState = record.getSenderKeyState();
-        if (!senderKeyState) {
-            throw new Error('No session to encrypt message');
-        }
-        const iteration = senderKeyState.getSenderChainKey().getIteration();
-        const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
-        const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
-        const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
-        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
-        return senderKeyMessage.serialize();
+        return await this.queueJob(async () => {
+            const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+            if (!record) {
+                throw new Error('No SenderKeyRecord found for encryption');
+            }
+            const senderKeyState = record.getSenderKeyState();
+            if (!senderKeyState) {
+                throw new Error('No session to encrypt message');
+            }
+            const iteration = senderKeyState.getSenderChainKey().getIteration();
+            const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+            const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+            const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+            await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+            return senderKeyMessage.serialize();
+        });
     }
     async decrypt(senderKeyMessageBytes) {
-        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
-        if (!record) {
-            throw new Error('No SenderKeyRecord found for decryption');
-        }
-        const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
-        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
-        if (!senderKeyState) {
-            throw new Error('No session found to decrypt message');
-        }
-        senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
-        const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
-        const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
-        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
-        return plaintext;
+        return await this.queueJob(async () => {
+            const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+            if (!record) {
+                throw new Error('No SenderKeyRecord found for decryption');
+            }
+            const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+            const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+            if (!senderKeyState) {
+                throw new Error('No session found to decrypt message');
+            }
+            senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+            const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+            const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+            await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+            return plaintext;
+        });
     }
     getSenderKey(senderKeyState, iteration) {
         let senderChainKey = senderKeyState.getSenderChainKey();

package/lib/Signal/Group/queue-job.d.ts

@@ -1,2 +1 @@
 export default function queueJob<T>(bucket: string | number, awaitable: () => Promise<T>): Promise<T>;
-//# sourceMappingURL=queue-job.d.ts.map

package/lib/Signal/Group/queue-job.js

@@ -1,7 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueJob;
 const _queueAsyncBuckets = new Map();
 const _gcLimit = 10000;
 async function _asyncQueueExecutor(queue, cleanup) {
     let offt = 0;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
         const limit = Math.min(queue.length, _gcLimit);
         for (let i = offt; i < limit; i++) {
@@ -28,7 +32,7 @@ async function _asyncQueueExecutor(queue, cleanup) {
     }
     cleanup();
 }
-export default function queueJob(bucket, awaitable) {
+function queueJob(bucket, awaitable) {
     // Skip name assignment since it's readonly in strict mode
     if (typeof bucket !== 'string') {
         console.warn('Unhandled bucket type (for naming):', typeof bucket, bucket);
@@ -51,4 +55,3 @@ export default function queueJob(bucket, awaitable) {
     }
     return job;
 }
-//# sourceMappingURL=queue-job.js.map

package/lib/Signal/libsignal.js

@@ -51,15 +51,11 @@ function makeLibSignalRepository(auth) {
         max: 500,
         ttl: 5 * 60 * 1000
     });
-    const parsedKeys = auth.keys;
     const repository = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
-            // Use transaction to ensure atomicity
-            return parsedKeys.transaction(async () => {
-                return cipher.decrypt(msg);
-            });
+            return cipher.decrypt(msg);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
             const builder = new Group_1.GroupSessionBuilder(storage);
@@ -73,32 +69,23 @@ function makeLibSignalRepository(auth) {
             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());
-                }
-                await builder.process(senderName, senderMsg);
-            });
+            await builder.process(senderName, senderMsg);
         },
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
-            // Use transaction to ensure atomicity
-            return parsedKeys.transaction(async () => {
-                let result;
-                switch (type) {
-                    case 'pkmsg':
-                        result = await session.decryptPreKeyWhisperMessage(ciphertext);
-                        break;
-                    case 'msg':
-                        result = await session.decryptWhisperMessage(ciphertext);
-                        break;
-                    default:
-                        throw new Error(`Unknown message type: ${type}`);
-                }
-                return result;
-            });
+            let result;
+            switch (type) {
+                case 'pkmsg':
+                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                    break;
+                case 'msg':
+                    result = await session.decryptWhisperMessage(ciphertext);
+                    break;
+                default:
+                    throw new Error(`Unknown message type: ${type}`);
+            }
+            return result;
         },
         async encryptMessage({ jid, data }) {
             // LID SINGLE SOURCE OF TRUTH: Always prefer LID when available
@@ -127,36 +114,29 @@ function makeLibSignalRepository(auth) {
             }
             const addr = jidToSignalProtocolAddress(encryptionJid);
             const cipher = new libsignal.SessionCipher(storage, addr);
-            // 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') };
-            });
+            const { type: sigType, body } = await cipher.encrypt(data);
+            const type = sigType === 3 ? 'pkmsg' : 'msg';
+            return { type, ciphertext: Buffer.from(body, 'binary') };
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId);
             const builder = new Group_1.GroupSessionBuilder(storage);
             const senderNameStr = senderName.toString();
-            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());
-                }
-                const senderKeyDistributionMessage = await builder.create(senderName);
-                const session = new Group_1.GroupCipher(storage, senderName);
-                const ciphertext = await session.encrypt(data);
-                return {
-                    ciphertext,
-                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
-                };
-            });
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName);
+            const session = new Group_1.GroupCipher(storage, senderName);
+            const ciphertext = await session.encrypt(data);
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+            };
         },
         async injectE2ESession({ jid, session }) {
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            return parsedKeys.transaction(async () => {
-                await cipher.initOutgoing(session);
-            });
+            await cipher.initOutgoing(session);
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
@@ -283,7 +263,6 @@ function signalStorage({ creds, keys }, lidMapping) {
             }
             return null;
         },
-        // 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/Signal/lid-mapping.d.ts

@@ -1,7 +1,9 @@
 import type { SignalKeyStoreWithTransaction } from '../Types';
 export declare class LIDMappingStore {
     private readonly keys;
-    constructor(keys: SignalKeyStoreWithTransaction);
+    private getLIDFromPN?;
+    private getPNFromLID?;
+    constructor(keys: SignalKeyStoreWithTransaction, getLIDFromPN?: (pn: string) => Promise<string | null>, getPNFromLID?: (lid: string) => Promise<string | null>);
     /**
      * Store LID-PN mapping - USER LEVEL
      */

package/lib/Signal/lid-mapping.js

@@ -7,8 +7,10 @@ exports.LIDMappingStore = void 0;
 const logger_1 = __importDefault(require("../Utils/logger"));
 const WABinary_1 = require("../WABinary");
 class LIDMappingStore {
-    constructor(keys) {
+    constructor(keys, getLIDFromPN, getPNFromLID) {
         this.keys = keys;
+        this.getLIDFromPN = getLIDFromPN;
+        this.getPNFromLID = getPNFromLID;
     }
     /**
      * Store LID-PN mapping - USER LEVEL
@@ -49,7 +51,19 @@ class LIDMappingStore {
         // Look up user-level mapping (whatsmeow approach)
         const pnUser = decoded.user;
         const stored = await this.keys.get('lid-mapping', [pnUser]);
-        const lidUser = stored[pnUser];
+        let lidUser = stored[pnUser];
+        if (!lidUser) {
+            if (this.getLIDFromPN) {
+                const lid = await this.getLIDFromPN(`${pnUser}@s.whatsapp.net`);
+                if (lid) {
+                    const decodedLid = (0, WABinary_1.jidDecode)(lid);
+                    if (decodedLid) {
+                        lidUser = decodedLid.user;
+                        await this.storeLIDPNMapping(`${lidUser}@lid`, `${pnUser}@s.whatsapp.net`);
+                    }
+                }
+            }
+        }
         if (!lidUser) {
             logger_1.default.trace(`No LID mapping found for PN user ${pnUser}`);
             return null;
@@ -74,7 +88,19 @@ class LIDMappingStore {
         // Look up reverse user mapping
         const lidUser = decoded.user;
         const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`]);
-        const pnUser = stored[`${lidUser}_reverse`];
+        let pnUser = stored[`${lidUser}_reverse`];
+        if (!pnUser) {
+            if (this.getPNFromLID) {
+                const pn = await this.getPNFromLID(`${lidUser}@lid`);
+                if (pn) {
+                    const decodedJid = (0, WABinary_1.jidDecode)(pn);
+                    if (decodedJid) {
+                        pnUser = decodedJid.user;
+                        await this.storeLIDPNMapping(`${lidUser}@lid`, `${pnUser}@s.whatsapp.net`);
+                    }
+                }
+            }
+        }
         if (!pnUser || typeof pnUser !== 'string') {
             logger_1.default.trace(`No reverse mapping found for LID user: ${lidUser}`);
             return null;

package/lib/Socket/messages-recv.js

@@ -642,11 +642,11 @@ const makeMessagesRecvSocket = (config) => {
                     if (msg) {
                         const fromMe = (0, WABinary_1.areJidsSameUser)(node.attrs.participant || remoteJid, authState.creds.me.id);
                         msg.key = {
+                            ...(msg.key || {}),
                             remoteJid,
                             fromMe,
                             participant: node.attrs.participant,
-                            id: node.attrs.id,
-                            ...(msg.key || {})
+                            id: node.attrs.id
                         };
                         (_a = msg.participant) !== null && _a !== void 0 ? _a : (msg.participant = node.attrs.participant);
                         msg.messageTimestamp = +node.attrs.t;

package/lib/Types/Auth.d.ts

@@ -100,5 +100,7 @@ export type SignalAuthState = {
 export type AuthenticationState = {
     creds: AuthenticationCreds;
     keys: SignalKeyStore;
+    getLIDFromPN?: (pn: string) => Promise<string | null>;
+    getPNFromLID?: (lid: string) => Promise<string | null>;
 };
 export {};

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

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

package/lib/Utils/auth-utils.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initAuthCreds = exports.addTransactionCapability = void 0;
 exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
 const node_cache_1 = __importDefault(require("@cacheable/node-cache"));
-const async_mutex_1 = require("async-mutex");
 const crypto_1 = require("crypto");
 const Defaults_1 = require("../Defaults");
 const crypto_2 = require("./crypto");
@@ -24,51 +23,45 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
             useClones: false,
             deleteOnExpire: true
         });
-    // Mutex for protecting cache operations
-    const cacheMutex = new async_mutex_1.Mutex();
     function getUniqueId(type, id) {
         return `${type}.${id}`;
     }
     return {
         async get(type, ids) {
-            return cacheMutex.runExclusive(async () => {
-                const data = {};
-                const idsToFetch = [];
-                for (const id of ids) {
-                    const item = cache.get(getUniqueId(type, id));
-                    if (typeof item !== 'undefined') {
-                        data[id] = item;
-                    }
-                    else {
-                        idsToFetch.push(id);
-                    }
+            const data = {};
+            const idsToFetch = [];
+            for (const id of ids) {
+                const item = cache.get(getUniqueId(type, id));
+                if (typeof item !== 'undefined') {
+                    data[id] = item;
                 }
-                if (idsToFetch.length) {
-                    logger === null || logger === void 0 ? void 0 : logger.trace({ items: idsToFetch.length }, 'loading from store');
-                    const fetched = await store.get(type, idsToFetch);
-                    for (const id of idsToFetch) {
-                        const item = fetched[id];
-                        if (item) {
-                            data[id] = item;
-                            cache.set(getUniqueId(type, id), item);
-                        }
+                else {
+                    idsToFetch.push(id);
+                }
+            }
+            if (idsToFetch.length) {
+                logger === null || logger === void 0 ? void 0 : logger.trace({ items: idsToFetch.length }, 'loading from store');
+                const fetched = await store.get(type, idsToFetch);
+                for (const id of idsToFetch) {
+                    const item = fetched[id];
+                    if (item) {
+                        data[id] = item;
+                        cache.set(getUniqueId(type, id), item);
                     }
                 }
-                return data;
-            });
+            }
+            return data;
         },
         async set(data) {
-            return cacheMutex.runExclusive(async () => {
-                let keys = 0;
-                for (const type in data) {
-                    for (const id in data[type]) {
-                        cache.set(getUniqueId(type, id), data[type][id]);
-                        keys += 1;
-                    }
+            let keys = 0;
+            for (const type in data) {
+                for (const id in data[type]) {
+                    cache.set(getUniqueId(type, id), data[type][id]);
+                    keys += 1;
                 }
-                logger === null || logger === void 0 ? void 0 : logger.trace({ keys }, 'updated cache');
-                await store.set(data);
-            });
+            }
+            logger === null || logger === void 0 ? void 0 : logger.trace({ keys }, 'updated cache');
+            await store.set(data);
         },
         async clear() {
             var _a;
@@ -77,145 +70,6 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
         }
     };
 }
-// Module-level specialized mutexes for pre-key operations
-const preKeyMutex = new async_mutex_1.Mutex();
-const signedPreKeyMutex = new async_mutex_1.Mutex();
-/**
- * Get the appropriate mutex for the key type
- */
-const getPreKeyMutex = (keyType) => {
-    return keyType === 'signed-pre-key' ? signedPreKeyMutex : preKeyMutex;
-};
-/**
- * Handles pre-key operations with mutex protection
- */
-async function handlePreKeyOperations(data, keyType, transactionCache, mutations, logger, isInTransaction, state) {
-    const mutex = getPreKeyMutex(keyType);
-    await mutex.runExclusive(async () => {
-        const keyData = data[keyType];
-        if (!keyData)
-            return;
-        // Ensure structures exist
-        transactionCache[keyType] = transactionCache[keyType] || {};
-        mutations[keyType] = mutations[keyType] || {};
-        // Separate deletions from updates for batch processing
-        const deletionKeys = [];
-        const updateKeys = [];
-        for (const keyId in keyData) {
-            if (keyData[keyId] === null) {
-                deletionKeys.push(keyId);
-            }
-            else {
-                updateKeys.push(keyId);
-            }
-        }
-        // Process updates first (no validation needed)
-        for (const keyId of updateKeys) {
-            if (transactionCache[keyType]) {
-                transactionCache[keyType][keyId] = keyData[keyId];
-            }
-            if (mutations[keyType]) {
-                mutations[keyType][keyId] = keyData[keyId];
-            }
-        }
-        // Process deletions with validation
-        if (deletionKeys.length === 0)
-            return;
-        if (isInTransaction) {
-            // In transaction, only allow deletion if key exists in cache
-            for (const keyId of deletionKeys) {
-                if (transactionCache[keyType]) {
-                    transactionCache[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}`);
-                }
-            }
-            return;
-        }
-        // Outside transaction, batch validate all deletions
-        if (!state)
-            return;
-        const existingKeys = await state.get(keyType, deletionKeys);
-        for (const keyId of deletionKeys) {
-            if (existingKeys[keyId]) {
-                if (transactionCache[keyType])
-                    transactionCache[keyType][keyId] = null;
-                if (mutations[keyType])
-                    mutations[keyType][keyId] = null;
-            }
-            else {
-                logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
-            }
-        }
-    });
-}
-/**
- * Handles normal key operations for transactions
- */
-function handleNormalKeyOperations(data, key, transactionCache, mutations) {
-    Object.assign(transactionCache[key], data[key]);
-    mutations[key] = mutations[key] || {};
-    Object.assign(mutations[key], data[key]);
-}
-/**
- * Process pre-key deletions with validation
- */
-async function processPreKeyDeletions(data, keyType, state, logger) {
-    const mutex = getPreKeyMutex(keyType);
-    await mutex.runExclusive(async () => {
-        const keyData = data[keyType];
-        if (!keyData)
-            return;
-        // Validate deletions
-        for (const keyId in keyData) {
-            if (keyData[keyId] === null) {
-                const existingKeys = await state.get(keyType, [keyId]);
-                if (!existingKeys[keyId]) {
-                    logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
-                    if (data[keyType])
-                        delete data[keyType][keyId];
-                }
-            }
-        }
-    });
-}
-/**
- * Executes a function with mutexes acquired for given key types
- * Uses async-mutex's runExclusive with efficient batching
- */
-async function withMutexes(keyTypes, getKeyTypeMutex, fn) {
-    if (keyTypes.length === 0) {
-        return fn();
-    }
-    if (keyTypes.length === 1) {
-        return getKeyTypeMutex(keyTypes[0]).runExclusive(fn);
-    }
-    // For multiple mutexes, sort by key type to prevent deadlocks
-    // Then acquire all mutexes in order using Promise.all for better efficiency
-    const sortedKeyTypes = [...keyTypes].sort();
-    const mutexes = sortedKeyTypes.map(getKeyTypeMutex);
-    // Acquire all mutexes in order to prevent deadlocks
-    const releases = [];
-    try {
-        for (const mutex of mutexes) {
-            releases.push(await mutex.acquire());
-        }
-        return await fn();
-    }
-    finally {
-        // Release in reverse order
-        while (releases.length > 0) {
-            const release = releases.pop();
-            if (release)
-                release();
-        }
-    }
-}
 /**
  * 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
@@ -229,81 +83,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
     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) {
-        let mutex = keyTypeMutexes.get(type);
-        if (!mutex) {
-            // Create regular mutex, timeout only for critical operations
-            mutex = new async_mutex_1.Mutex();
-            keyTypeMutexes.set(type, mutex);
-        }
-        return mutex;
-    }
-    // Get or create a mutex for a specific sender key name
-    function getSenderKeyMutex(senderKeyName) {
-        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
-    function queueSenderKeyOperation(senderKeyName, operation) {
-        return getSenderKeyMutex(senderKeyName).runExclusive(operation);
-    }
-    // Check if we are currently in a transaction
-    function isInTransaction() {
-        return transactionsInProgress > 0;
-    }
     return {
         get: async (type, ids) => {
             if (isInTransaction()) {
@@ -312,30 +92,9 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                 // only fetch if there are any items to fetch
                 if (idsRequiringFetch.length) {
                     dbQueriesInTransaction += 1;
-                    // Use per-sender-key queue for sender-key operations when possible
-                    if (type === 'sender-key') {
-                        logger.info({ idsRequiringFetch }, 'processing sender keys in transaction');
-                        // For sender keys, process each one with queued operations to maintain serialization
-                        for (const senderKeyName of idsRequiringFetch) {
-                            await queueSenderKeyOperation(senderKeyName, async () => {
-                                logger.info({ senderKeyName }, 'fetching sender key in transaction');
-                                const result = await state.get(type, [senderKeyName]);
-                                // Update transaction cache
-                                transactionCache[type] || (transactionCache[type] = {});
-                                Object.assign(transactionCache[type], result);
-                                logger.info({ senderKeyName, hasResult: !!result[senderKeyName] }, 'sender key fetch complete');
-                            });
-                        }
-                    }
-                    else {
-                        // Use runExclusive for cleaner mutex handling
-                        await getKeyTypeMutex(type).runExclusive(async () => {
-                            const result = await state.get(type, idsRequiringFetch);
-                            // Update transaction cache
-                            transactionCache[type] || (transactionCache[type] = {});
-                            Object.assign(transactionCache[type], result);
-                        });
-                    }
+                    const result = await state.get(type, idsRequiringFetch);
+                    transactionCache[type] || (transactionCache[type] = {});
+                    Object.assign(transactionCache[type], result);
                 }
                 return ids.reduce((dict, id) => {
                     var _a;
@@ -347,90 +106,21 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                 }, {});
             }
             else {
-                // Not in transaction, fetch directly with queue protection
-                if (type === 'sender-key') {
-                    // For sender keys, use individual queues to maintain per-key serialization
-                    const results = {};
-                    for (const senderKeyName of ids) {
-                        const result = await queueSenderKeyOperation(senderKeyName, async () => await state.get(type, [senderKeyName]));
-                        Object.assign(results, result);
-                    }
-                    return results;
-                }
-                else {
-                    return await getKeyTypeMutex(type).runExclusive(() => state.get(type, ids));
-                }
+                return state.get(type, ids);
             }
         },
-        set: async (data) => {
+        set: data => {
             if (isInTransaction()) {
                 logger.trace({ types: Object.keys(data) }, 'caching in transaction');
-                for (const key_ in data) {
-                    const key = key_;
+                for (const key in data) {
                     transactionCache[key] = transactionCache[key] || {};
-                    // Special handling for pre-keys and signed-pre-keys
-                    if (key === 'pre-key') {
-                        await handlePreKeyOperations(data, key, transactionCache, mutations, logger, true);
-                    }
-                    else {
-                        // Normal handling for other key types
-                        handleNormalKeyOperations(data, key, transactionCache, mutations);
-                    }
+                    Object.assign(transactionCache[key], data[key]);
+                    mutations[key] = mutations[key] || {};
+                    Object.assign(mutations[key], data[key]);
                 }
             }
             else {
-                // Not in transaction, apply directly with mutex protection
-                const hasSenderKeys = 'sender-key' in data;
-                const senderKeyNames = hasSenderKeys ? Object.keys(data['sender-key'] || {}) : [];
-                if (hasSenderKeys) {
-                    logger.info({ senderKeyNames }, 'processing sender key set operations');
-                    // Handle sender key operations with per-key queues
-                    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]
-                                }
-                            };
-                            logger.trace({ senderKeyName }, 'storing sender key');
-                            // Apply changes to the store
-                            await state.set(senderKeyData);
-                            logger.trace({ senderKeyName }, 'sender key stored');
-                        });
-                    }
-                    // Handle any non-sender-key data with regular mutexes
-                    const nonSenderKeyData = { ...data };
-                    delete nonSenderKeyData['sender-key'];
-                    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 key_ in nonSenderKeyData) {
-                                const keyType = key_;
-                                if (keyType === 'pre-key') {
-                                    await processPreKeyDeletions(nonSenderKeyData, keyType, state, logger);
-                                }
-                            }
-                            // Apply changes to the store
-                            await state.set(nonSenderKeyData);
-                        });
-                    }
-                }
-                else {
-                    // 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 key_ in data) {
-                            const keyType = key_;
-                            if (keyType === 'pre-key') {
-                                await processPreKeyDeletions(data, keyType, state, logger);
-                            }
-                        }
-                        // Apply changes to the store
-                        await state.set(data);
-                    });
-                }
+                return state.set(data);
             }
         },
         isInTransaction,
@@ -479,6 +169,9 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             return result;
         }
     };
+    function isInTransaction() {
+        return transactionsInProgress > 0;
+    }
 };
 exports.addTransactionCapability = addTransactionCapability;
 const initAuthCreds = () => {

package/package.json

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