@ryuu-reinzz/baileys 3.0.0-beta.2 → 3.0.0-beta.21

package/lib/Socket/socket.js

@@ -3,7 +3,7 @@ import { randomBytes } from 'crypto';
 import { URL } from 'url';
 import { promisify } from 'util';
 import { proto } from '../../WAProto/index.js';
-import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT, MIN_UPLOAD_INTERVAL, NOISE_WA_HEADER, UPLOAD_TIMEOUT } from '../Defaults/index.js';
+import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT, MIN_UPLOAD_INTERVAL, NOISE_WA_HEADER, PROCESSABLE_HISTORY_TYPES, TimeMs, UPLOAD_TIMEOUT } from '../Defaults/index.js';
 import { DisconnectReason } from '../Types/index.js';
 import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, makeEventBuffer, makeNoiseHandler, promiseTimeout, signedKeyPair, xmppSignedPreKey } from '../Utils/index.js';
 import { getPlatformId } from '../Utils/browser-utils.js';
@@ -20,10 +20,16 @@ import { WebSocketClient } from './Client/index.js';
 export const makeSocket = (config) => {
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config;
     const publicWAMBuffer = new BinaryInfo();
+    let serverTimeOffsetMs = 0;
     const uqTagId = generateMdTagPrefix();
     const generateMessageTag = () => `${uqTagId}${epoch++}`;
     if (printQRInTerminal) {
-        console.warn('⚠️ The printQRInTerminal option has been deprecated. You will no longer receive QR codes in the terminal automatically. Please listen to the connection.update event yourself and handle the QR your way. You can remove this message by removing this opttion. This message will be removed in a future version.');
+        logger.warn({}, '⚠️ The printQRInTerminal option has been deprecated. You will no longer receive QR codes in the terminal automatically. Please listen to the connection.update event yourself and handle the QR your way. You can remove this message by removing this opttion. This message will be removed in a future version.');
+    }
+    const syncDisabled = PROCESSABLE_HISTORY_TYPES.map(syncType => config.shouldSyncHistoryMessage({ syncType })).filter(x => x === false)
+        .length === PROCESSABLE_HISTORY_TYPES.length;
+    if (syncDisabled) {
+        logger.warn('⚠️ DANGER: DISABLING ALL SYNC BY shouldSyncHistoryMsg PREVENTS BAILEYS FROM ACCESSING INITIAL LID MAPPINGS, LEADING TO INSTABILIY AND SESSION ERRORS');
     }
     const url = typeof waWebSocketUrl === 'string' ? new URL(waWebSocketUrl) : waWebSocketUrl;
     if (config.mobile || url.protocol === 'tcp:') {
@@ -304,7 +310,7 @@ export const makeSocket = (config) => {
         const result = await awaitNextMessage(init);
         const handshake = proto.HandshakeMessage.decode(result);
         logger.trace({ handshake }, 'handshake recv from WA');
-        const keyEnc = await noise.processHandshake(handshake, creds.noiseKey);
+        const keyEnc = noise.processHandshake(handshake, creds.noiseKey);
         let node;
         if (!creds.me) {
             node = generateRegistrationNode(creds, config);
@@ -468,7 +474,7 @@ export const makeSocket = (config) => {
             }
         });
     };
-    const end = (error) => {
+    const end = async (error) => {
         if (closed) {
             logger.trace({ trace: error?.stack }, 'connection already closed');
             return;
@@ -482,7 +488,7 @@ export const makeSocket = (config) => {
         ws.removeAllListeners('message');
         if (!ws.isClosed && !ws.isClosing) {
             try {
-                ws.close();
+                await ws.close();
             }
             catch { }
         }
@@ -526,7 +532,7 @@ export const makeSocket = (config) => {
             it could be that the network is down
         */
         if (diff > keepAliveIntervalMs + 5000) {
-            end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+            void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
         }
         else if (ws.isOpen) {
             // if its all good, send a keep alive request
@@ -580,7 +586,7 @@ export const makeSocket = (config) => {
                 ]
             });
         }
-        end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
+        void end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
     const requestPairingCode = async (phoneNumber, customPairingCode) => {
         const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5));
@@ -672,13 +678,13 @@ export const makeSocket = (config) => {
         }
         catch (err) {
             logger.error({ err }, 'error in validating connection');
-            end(err);
+            void end(err);
         }
     });
     ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('close', () => void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
     // the server terminated the connection
-    ws.on('CB:xmlstreamend', () => end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('CB:xmlstreamend', () => void end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
     // QR gen
     ws.on('CB:iq,type:set,pair-device', async (stanza) => {
         const iq = {
@@ -702,7 +708,7 @@ export const makeSocket = (config) => {
             }
             const refNode = refNodes.shift();
             if (!refNode) {
-                end(new Boom('QR refs attempts ended', { statusCode: DisconnectReason.timedOut }));
+                void end(new Boom('QR refs attempts ended', { statusCode: DisconnectReason.timedOut }));
                 return;
             }
             const ref = refNode.content.toString('utf-8');
@@ -718,20 +724,23 @@ export const makeSocket = (config) => {
     ws.on('CB:iq,,pair-success', async (stanza) => {
         logger.debug('pair success recv');
         try {
+            updateServerTimeOffset(stanza);
             const { reply, creds: updatedCreds } = configureSuccessfulPairing(stanza, creds);
             logger.info({ me: updatedCreds.me, platform: updatedCreds.platform }, 'pairing configured successfully, expect to restart the connection...');
             ev.emit('creds.update', updatedCreds);
             ev.emit('connection.update', { isNewLogin: true, qr: undefined });
             await sendNode(reply);
+            void sendUnifiedSession();
         }
         catch (error) {
             logger.info({ trace: error.stack }, 'error in pairing');
-            end(error);
+            void end(error);
         }
     });
     // login complete
     ws.on('CB:success', async (node) => {
         try {
+            updateServerTimeOffset(node);
             await uploadPreKeysToServerIfRequired();
             await sendPassiveIq('active');
             // After successful login, validate our key-bundle against server
@@ -749,6 +758,7 @@ export const makeSocket = (config) => {
         clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
         ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
         ev.emit('connection.update', { connection: 'open' });
+        void sendUnifiedSession();
         if (node.attrs.lid && authState.creds.me?.id) {
             const myLID = node.attrs.lid;
             process.nextTick(async () => {
@@ -777,15 +787,15 @@ export const makeSocket = (config) => {
         const [reasonNode] = getAllBinaryNodeChildren(node);
         logger.error({ reasonNode, fullErrorNode: node }, 'stream errored out');
         const { reason, statusCode } = getErrorCodeFromStreamError(node);
-        end(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
+        void end(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
     });
     // stream fail, possible logout
     ws.on('CB:failure', (node) => {
         const reason = +(node.attrs.reason || 500);
-        end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
+        void end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
     });
     ws.on('CB:ib,,downgrade_webclient', () => {
-        end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
+        void end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
     });
     ws.on('CB:ib,,offline_preview', async (node) => {
         logger.info('offline preview received', JSON.stringify(node));
@@ -839,6 +849,48 @@ export const makeSocket = (config) => {
         }
         Object.assign(creds, update);
     });
+    const updateServerTimeOffset = ({ attrs }) => {
+        const tValue = attrs?.t;
+        if (!tValue) {
+            return;
+        }
+        const parsed = Number(tValue);
+        if (Number.isNaN(parsed) || parsed <= 0) {
+            return;
+        }
+        const localMs = Date.now();
+        serverTimeOffsetMs = parsed * 1000 - localMs;
+        logger.debug({ offset: serverTimeOffsetMs }, 'calculated server time offset');
+    };
+    const getUnifiedSessionId = () => {
+        const offsetMs = 3 * TimeMs.Day;
+        const now = Date.now() + serverTimeOffsetMs;
+        const id = (now + offsetMs) % TimeMs.Week;
+        return id.toString();
+    };
+    const sendUnifiedSession = async () => {
+        if (!ws.isOpen) {
+            return;
+        }
+        const node = {
+            tag: 'ib',
+            attrs: {},
+            content: [
+                {
+                    tag: 'unified_session',
+                    attrs: {
+                        id: getUnifiedSessionId()
+                    }
+                }
+            ]
+        };
+        try {
+            await sendNode(node);
+        }
+        catch (error) {
+            logger.debug({ error }, 'failed to send unified_session telemetry');
+        }
+    };
     return {
         type: 'md',
         ws,
@@ -862,6 +914,8 @@ export const makeSocket = (config) => {
         digestKeyBundle,
         rotateSignedPreKey,
         requestPairingCode,
+        updateServerTimeOffset,
+        sendUnifiedSession,
         wamBuffer: publicWAMBuffer,
         /** Waits for the connection to WA to reach a state */
         waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),

package/lib/Utils/auth-utils.js

@@ -46,6 +46,7 @@ export function makeCacheableSignalKeyStore(store, logger, _cache) {
                         const item = fetched[id];
                         if (item) {
                             data[id] = item;
+                            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
                             await cache.set(getUniqueId(type, id), item);
                         }
                     }
@@ -81,9 +82,11 @@ export function makeCacheableSignalKeyStore(store, logger, _cache) {
  */
 export const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
     const txStorage = new AsyncLocalStorage();
-    // Queues for concurrency control
+    // Queues for concurrency control (keyed by signal data type - bounded set)
     const keyQueues = new Map();
+    // Transaction mutexes with reference counting for cleanup
     const txMutexes = new Map();
+    const txMutexRefCounts = new Map();
     // Pre-key manager for specialized operations
     const preKeyManager = new PreKeyManager(state, logger);
     /**
@@ -101,9 +104,32 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
     function getTxMutex(key) {
         if (!txMutexes.has(key)) {
             txMutexes.set(key, new Mutex());
+            txMutexRefCounts.set(key, 0);
         }
         return txMutexes.get(key);
     }
+    /**
+     * Acquire a reference to a transaction mutex
+     */
+    function acquireTxMutexRef(key) {
+        const count = txMutexRefCounts.get(key) ?? 0;
+        txMutexRefCounts.set(key, count + 1);
+    }
+    /**
+     * Release a reference to a transaction mutex and cleanup if no longer needed
+     */
+    function releaseTxMutexRef(key) {
+        const count = (txMutexRefCounts.get(key) ?? 1) - 1;
+        txMutexRefCounts.set(key, count);
+        // Cleanup if no more references and mutex is not locked
+        if (count <= 0) {
+            const mutex = txMutexes.get(key);
+            if (mutex && !mutex.isLocked()) {
+                txMutexes.delete(key);
+                txMutexRefCounts.delete(key);
+            }
+        }
+    }
     /**
      * Check if currently in a transaction
      */
@@ -209,25 +235,32 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
                 return work();
             }
             // New transaction - acquire mutex and create context
-            return getTxMutex(key).runExclusive(async () => {
-                const ctx = {
-                    cache: {},
-                    mutations: {},
-                    dbQueries: 0
-                };
-                logger.trace('entering transaction');
-                try {
-                    const result = await txStorage.run(ctx, work);
-                    // Commit mutations
-                    await commitWithRetry(ctx.mutations);
-                    logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed');
-                    return result;
-                }
-                catch (error) {
-                    logger.error({ error }, 'transaction failed, rolling back');
-                    throw error;
-                }
-            });
+            const mutex = getTxMutex(key);
+            acquireTxMutexRef(key);
+            try {
+                return await mutex.runExclusive(async () => {
+                    const ctx = {
+                        cache: {},
+                        mutations: {},
+                        dbQueries: 0
+                    };
+                    logger.trace('entering transaction');
+                    try {
+                        const result = await txStorage.run(ctx, work);
+                        // Commit mutations
+                        await commitWithRetry(ctx.mutations);
+                        logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed');
+                        return result;
+                    }
+                    catch (error) {
+                        logger.error({ error }, 'transaction failed, rolling back');
+                        throw error;
+                    }
+                });
+            }
+            finally {
+                releaseTxMutexRef(key);
+            }
         }
     };
 };

package/lib/Utils/chat-utils.js

@@ -1,41 +1,37 @@
 import { Boom } from '@hapi/boom';
+import { expandAppStateKeys } from 'whatsapp-rust-bridge';
 import { proto } from '../../WAProto/index.js';
 import { LabelAssociationType } from '../Types/LabelAssociation.js';
 import { getBinaryNodeChild, getBinaryNodeChildren, isJidGroup, jidNormalizedUser } from '../WABinary/index.js';
-import { aesDecrypt, aesEncrypt, hkdf, hmacSign } from './crypto.js';
+import { aesDecrypt, aesEncrypt, hmacSign } from './crypto.js';
 import { toNumber } from './generics.js';
 import { LT_HASH_ANTI_TAMPERING } from './lt-hash.js';
 import { downloadContentFromMessage } from './messages-media.js';
-const mutationKeys = async (keydata) => {
-    const expanded = await hkdf(keydata, 160, { info: 'WhatsApp Mutation Keys' });
+import { emitSyncActionResults, processContactAction } from './sync-action-utils.js';
+const mutationKeys = (keydata) => {
+    const keys = expandAppStateKeys(keydata);
     return {
-        indexKey: expanded.slice(0, 32),
-        valueEncryptionKey: expanded.slice(32, 64),
-        valueMacKey: expanded.slice(64, 96),
-        snapshotMacKey: expanded.slice(96, 128),
-        patchMacKey: expanded.slice(128, 160)
+        indexKey: keys.indexKey,
+        valueEncryptionKey: keys.valueEncryptionKey,
+        valueMacKey: keys.valueMacKey,
+        snapshotMacKey: keys.snapshotMacKey,
+        patchMacKey: keys.patchMacKey
     };
 };
 const generateMac = (operation, data, keyId, key) => {
-    const getKeyData = () => {
-        let r;
-        switch (operation) {
-            case proto.SyncdMutation.SyncdOperation.SET:
-                r = 0x01;
-                break;
-            case proto.SyncdMutation.SyncdOperation.REMOVE:
-                r = 0x02;
-                break;
-        }
-        const buff = Buffer.from([r]);
-        return Buffer.concat([buff, Buffer.from(keyId, 'base64')]);
-    };
-    const keyData = getKeyData();
-    const last = Buffer.alloc(8); // 8 bytes
-    last.set([keyData.length], last.length - 1);
-    const total = Buffer.concat([keyData, data, last]);
+    const opByte = operation === proto.SyncdMutation.SyncdOperation.SET ? 0x01 : 0x02;
+    const keyIdBuffer = typeof keyId === 'string' ? Buffer.from(keyId, 'base64') : keyId;
+    const keyData = new Uint8Array(1 + keyIdBuffer.length);
+    keyData[0] = opByte;
+    keyData.set(keyIdBuffer, 1);
+    const last = new Uint8Array(8);
+    last[7] = keyData.length;
+    const total = new Uint8Array(keyData.length + data.length + last.length);
+    total.set(keyData, 0);
+    total.set(data, keyData.length);
+    total.set(last, keyData.length + data.length);
     const hmac = hmacSign(total, key, 'sha512');
-    return hmac.slice(0, 32);
+    return hmac.subarray(0, 32);
 };
 const to64BitNetworkOrder = (e) => {
     const buff = Buffer.alloc(8);
@@ -58,20 +54,18 @@ const makeLtHashGenerator = ({ indexValueMap, hash }) => {
                 delete indexValueMap[indexMacBase64];
             }
             else {
-                addBuffs.push(new Uint8Array(valueMac).buffer);
+                addBuffs.push(valueMac);
                 // add this index into the history map
                 indexValueMap[indexMacBase64] = { valueMac };
             }
             if (prevOp) {
-                subBuffs.push(new Uint8Array(prevOp.valueMac).buffer);
+                subBuffs.push(prevOp.valueMac);
             }
         },
-        finish: async () => {
-            const hashArrayBuffer = new Uint8Array(hash).buffer;
-            const result = await LT_HASH_ANTI_TAMPERING.subtractThenAdd(hashArrayBuffer, addBuffs, subBuffs);
-            const buffer = Buffer.from(result);
+        finish: () => {
+            const result = LT_HASH_ANTI_TAMPERING.subtractThenAdd(hash, subBuffs, addBuffs);
             return {
-                hash: buffer,
+                hash: Buffer.from(result),
                 indexValueMap
             };
         }
@@ -101,14 +95,14 @@ export const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, op
         version: apiVersion
     });
     const encoded = proto.SyncActionData.encode(dataProto).finish();
-    const keyValue = await mutationKeys(key.keyData);
+    const keyValue = mutationKeys(key.keyData);
     const encValue = aesEncrypt(encoded, keyValue.valueEncryptionKey);
     const valueMac = generateMac(operation, encValue, encKeyId, keyValue.valueMacKey);
     const indexMac = hmacSign(indexBuffer, keyValue.indexKey);
     // update LT hash
     const generator = makeLtHashGenerator(state);
     generator.mix({ indexMac, valueMac, operation });
-    Object.assign(state, await generator.finish());
+    Object.assign(state, generator.finish());
     state.version += 1;
     const snapshotMac = generateSnapshotMac(state.hash, state.version, type, keyValue.snapshotMacKey);
     const patch = {
@@ -136,6 +130,7 @@ export const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, op
 };
 export const decodeSyncdMutations = async (msgMutations, initialState, getAppStateSyncKey, onMutation, validateMacs) => {
     const ltGenerator = makeLtHashGenerator(initialState);
+    const derivedKeyCache = new Map();
     // indexKey used to HMAC sign record.index.blob
     // valueEncryptionKey used to AES-256-CBC encrypt record.value.blob[0:-32]
     // the remaining record.value.blob[0:-32] is the mac, it the HMAC sign of key.keyId + decoded proto data + length of bytes in keyId
@@ -145,9 +140,9 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
         const operation = 'operation' in msgMutation ? msgMutation.operation : proto.SyncdMutation.SyncdOperation.SET;
         const record = 'record' in msgMutation && !!msgMutation.record ? msgMutation.record : msgMutation;
         const key = await getKey(record.keyId.id);
-        const content = Buffer.from(record.value.blob);
-        const encContent = content.slice(0, -32);
-        const ogValueMac = content.slice(-32);
+        const content = record.value.blob;
+        const encContent = content.subarray(0, -32);
+        const ogValueMac = content.subarray(-32);
         if (validateMacs) {
             const contentHmac = generateMac(operation, encContent, record.keyId.id, key.valueMacKey);
             if (Buffer.compare(contentHmac, ogValueMac) !== 0) {
@@ -170,9 +165,13 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
             operation: operation
         });
     }
-    return await ltGenerator.finish();
+    return ltGenerator.finish();
     async function getKey(keyId) {
         const base64Key = Buffer.from(keyId).toString('base64');
+        const cached = derivedKeyCache.get(base64Key);
+        if (cached) {
+            return cached;
+        }
         const keyEnc = await getAppStateSyncKey(base64Key);
         if (!keyEnc) {
             throw new Boom(`failed to find key "${base64Key}" to decode mutation`, {
@@ -180,7 +179,9 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
                 data: { msgMutations }
             });
         }
-        return mutationKeys(keyEnc.keyData);
+        const keys = mutationKeys(keyEnc.keyData);
+        derivedKeyCache.set(base64Key, keys);
+        return keys;
     }
 };
 export const decodeSyncdPatch = async (msg, name, initialState, getAppStateSyncKey, onMutation, validateMacs) => {
@@ -190,7 +191,7 @@ export const decodeSyncdPatch = async (msg, name, initialState, getAppStateSyncK
         if (!mainKeyObj) {
             throw new Boom(`failed to find key "${base64Key}" to decode patch`, { statusCode: 404, data: { msg } });
         }
-        const mainKey = await mutationKeys(mainKeyObj.keyData);
+        const mainKey = mutationKeys(mainKeyObj.keyData);
         const mutationmacs = msg.mutations.map(mutation => mutation.record.value.blob.slice(-32));
         const patchMac = generatePatchMac(msg.snapshotMac, mutationmacs, toNumber(msg.version.version), name, mainKey.patchMacKey);
         if (Buffer.compare(patchMac, msg.patchMac) !== 0) {
@@ -268,7 +269,7 @@ export const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, mi
         if (!keyEnc) {
             throw new Boom(`failed to find key "${base64Key}" to decode mutation`);
         }
-        const result = await mutationKeys(keyEnc.keyData);
+        const result = mutationKeys(keyEnc.keyData);
         const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
         if (Buffer.compare(snapshot.mac, computedSnapshotMac) !== 0) {
             throw new Boom(`failed to verify LTHash at ${newState.version} of ${name} from snapshot`);
@@ -310,7 +311,7 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
             if (!keyEnc) {
                 throw new Boom(`failed to find key "${base64Key}" to decode mutation`);
             }
-            const result = await mutationKeys(keyEnc.keyData);
+            const result = mutationKeys(keyEnc.keyData);
             const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
             if (Buffer.compare(snapshotMac, computedSnapshotMac) !== 0) {
                 throw new Boom(`failed to verify LTHash at ${newState.version} of ${name}`);
@@ -665,14 +666,8 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
         });
     }
     else if (action?.contactAction) {
-        ev.emit('contacts.upsert', [
-            {
-                id: id,
-                name: action.contactAction.fullName,
-                lid: action.contactAction.lidJid || undefined,
-                phoneNumber: action.contactAction.pnJid || undefined
-            }
-        ]);
+        const results = processContactAction(action.contactAction, id, logger);
+        emitSyncActionResults(ev, results);
     }
     else if (action?.pushNameSetting) {
         const name = action?.pushNameSetting?.name;
@@ -741,6 +736,60 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
                 }
         });
     }
+    else if (action?.localeSetting?.locale) {
+        ev.emit('settings.update', { setting: 'locale', value: action.localeSetting.locale });
+    }
+    else if (action?.timeFormatAction) {
+        ev.emit('settings.update', { setting: 'timeFormat', value: action.timeFormatAction });
+    }
+    else if (action?.pnForLidChatAction) {
+        if (action.pnForLidChatAction.pnJid) {
+            ev.emit('lid-mapping.update', { lid: id, pn: action.pnForLidChatAction.pnJid });
+        }
+    }
+    else if (action?.privacySettingRelayAllCalls) {
+        ev.emit('settings.update', {
+            setting: 'privacySettingRelayAllCalls',
+            value: action.privacySettingRelayAllCalls
+        });
+    }
+    else if (action?.statusPrivacy) {
+        ev.emit('settings.update', { setting: 'statusPrivacy', value: action.statusPrivacy });
+    }
+    else if (action?.lockChatAction) {
+        ev.emit('chats.lock', { id: id, locked: !!action.lockChatAction.locked });
+    }
+    else if (action?.privacySettingDisableLinkPreviewsAction) {
+        ev.emit('settings.update', {
+            setting: 'disableLinkPreviews',
+            value: action.privacySettingDisableLinkPreviewsAction
+        });
+    }
+    else if (action?.notificationActivitySettingAction?.notificationActivitySetting) {
+        ev.emit('settings.update', {
+            setting: 'notificationActivitySetting',
+            value: action.notificationActivitySettingAction.notificationActivitySetting
+        });
+    }
+    else if (action?.lidContactAction) {
+        ev.emit('contacts.upsert', [
+            {
+                id: id,
+                name: action.lidContactAction.fullName ||
+                    action.lidContactAction.firstName ||
+                    action.lidContactAction.username ||
+                    undefined,
+                lid: id,
+                phoneNumber: undefined
+            }
+        ]);
+    }
+    else if (action?.privacySettingChannelsPersonalisedRecommendationAction) {
+        ev.emit('settings.update', {
+            setting: 'channelsPersonalisedRecommendation',
+            value: action.privacySettingChannelsPersonalisedRecommendationAction
+        });
+    }
     else {
         logger?.debug({ syncAction, id }, 'unprocessable update');
     }

package/lib/Utils/crypto.js

@@ -1,6 +1,7 @@
 import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes } from 'crypto';
 import * as curve from 'libsignal/src/curve.js';
 import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
+export { md5, hkdf } from 'whatsapp-rust-bridge';
 // insure browser & node compatibility
 const { subtle } = globalThis.crypto;
 /** prefix version byte to the pub keys, required for some curve crypto functions */
@@ -69,7 +70,7 @@ export function aesDecryptCTR(ciphertext, key, iv) {
 }
 /** decrypt AES 256 CBC; where the IV is prefixed to the buffer */
 export function aesDecrypt(buffer, key) {
-    return aesDecryptWithIV(buffer.slice(16, buffer.length), key, buffer.slice(0, 16));
+    return aesDecryptWithIV(buffer.subarray(16), key, buffer.subarray(0, 16));
 }
 /** decrypt AES 256 CBC */
 export function aesDecryptWithIV(buffer, key, IV) {
@@ -94,31 +95,6 @@ export function hmacSign(buffer, key, variant = 'sha256') {
 export function sha256(buffer) {
     return createHash('sha256').update(buffer).digest();
 }
-export function md5(buffer) {
-    return createHash('md5').update(buffer).digest();
-}
-// HKDF key expansion
-export async function hkdf(buffer, expandedLength, info) {
-    // Normalize to a Uint8Array whose underlying buffer is a regular ArrayBuffer (not ArrayBufferLike)
-    // Cloning via new Uint8Array(...) guarantees the generic parameter is ArrayBuffer which satisfies WebCrypto types.
-    const inputKeyMaterial = new Uint8Array(buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer));
-    // Set default values if not provided
-    const salt = info.salt ? new Uint8Array(info.salt) : new Uint8Array(0);
-    const infoBytes = info.info ? new TextEncoder().encode(info.info) : new Uint8Array(0);
-    // Import the input key material (cast to BufferSource to appease TS DOM typings)
-    const importedKey = await subtle.importKey('raw', inputKeyMaterial, { name: 'HKDF' }, false, [
-        'deriveBits'
-    ]);
-    // Derive bits using HKDF
-    const derivedBits = await subtle.deriveBits({
-        name: 'HKDF',
-        hash: 'SHA-256',
-        salt: salt,
-        info: infoBytes
-    }, importedKey, expandedLength * 8 // Convert bytes to bits
-    );
-    return Buffer.from(derivedBits);
-}
 export async function derivePairingCodeKey(pairingCode, salt) {
     // Convert inputs to formats Web Crypto API can work with
     const encoder = new TextEncoder();