@nexustechpro/baileys 2.0.5 → 2.0.6

package/lib/Utils/process-message.js

@@ -1,9 +1,11 @@
 import { proto } from '../../WAProto/index.js';
+import { Boom } from '@hapi/boom'
 import { WAMessageStubType } from '../Types/index.js';
 import { getContentType, normalizeMessageContent } from '../Utils/messages.js';
 import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJidStatusBroadcast, jidDecode, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
 import { aesDecryptGCM, hmacSign } from './crypto.js';
-import { toNumber } from './generics.js';
+import { resolveTcTokenJid, buildMergedTcTokenIndexWrite } from './tc-token-utils.js'
+import { toNumber } from './generics.js'
 import { downloadAndProcessHistorySyncNotification } from './history.js';
 const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_GROUP_VIDEO,
@@ -73,10 +75,9 @@ export const shouldIncrementChatUnread = (message) => !message.key.fromMe && !me
  * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
  */
 export const getChatId = ({ remoteJid, participant, fromMe }) => {
-    if (isJidBroadcast(remoteJid) && !isJidStatusBroadcast(remoteJid) && !fromMe) {
-        return participant;
-    }
-    return remoteJid;
+    if (!remoteJid) throw new Boom('Cannot derive chat id: message key is missing remoteJid', { data: { remoteJid, participant, fromMe } })
+    if (isJidBroadcast(remoteJid) && !isJidStatusBroadcast(remoteJid) && !fromMe) return participant
+    return remoteJid
 };
 /**
  * Decrypt a poll vote
@@ -101,7 +102,34 @@ export function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsg
         return Buffer.from(txt);
     }
 }
-const processMessage = async (message, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, signalRepository, keyStore, logger, options }) => {
+
+async function storeTcTokensFromHistorySync(chats, signalRepository, keyStore, logger) {
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping)
+    const candidates = []
+    for (const chat of chats) {
+        const ts = chat.tcTokenTimestamp ? toNumber(chat.tcTokenTimestamp) : 0
+        if (chat.tcToken?.length && ts > 0) { const jid = jidNormalizedUser(chat.id); const storageJid = await resolveTcTokenJid(jid, getLIDForPN); candidates.push({ storageJid, token: Buffer.from(chat.tcToken), ts, senderTs: chat.tcTokenSenderTimestamp ? toNumber(chat.tcTokenSenderTimestamp) : undefined }) }
+    }
+    if (!candidates.length) return
+    const jids = candidates.map(c => c.storageJid)
+    const existing = await keyStore.get('tctoken', jids)
+    const entries = {}
+    for (const c of candidates) {
+        const existingEntry = existing[c.storageJid]
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0
+        if (existingTs > 0 && existingTs >= c.ts) continue
+        entries[c.storageJid] = { ...existingEntry, token: c.token, timestamp: String(c.ts), ...(c.senderTs !== undefined ? { senderTimestamp: c.senderTs } : {}) }
+    }
+    if (Object.keys(entries).length) {
+        logger?.debug({ count: Object.keys(entries).length }, 'storing tctokens from history sync')
+        try { const indexWrite = await buildMergedTcTokenIndexWrite(keyStore, Object.keys(entries)); await keyStore.set({ tctoken: { ...entries, ...indexWrite } }) }
+        catch (err) { logger?.warn({ err }, 'failed to store tctokens from history sync') }
+    }
+}
+
+const SELF_ONLY_TYPES = new Set([proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION, proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE, proto.Message.ProtocolMessage.Type.LID_MIGRATION_MAPPING_SYNC, proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE])
+
+const processMessage = async (message, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, signalRepository, keyStore, logger, options, getMessage }) => {
     const meId = creds.me.id;
     const { accountSettings } = creds;
     const chat = { id: jidNormalizedUser(getChatId(message.key)) };
@@ -123,6 +151,7 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
     }
     const protocolMsg = content?.protocolMessage;
     if (protocolMsg) {
+        if (protocolMsg.type !== null && protocolMsg.type !== undefined && SELF_ONLY_TYPES.has(protocolMsg.type) && !message.key.fromMe) { logger?.warn({ msgId: message.key.id, type: protocolMsg.type, from: message.key.participant || message.key.remoteJid }, 'dropping spoofed self-only protocolMessage from non-self origin'); return }
         switch (protocolMsg.type) {
             case proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION:
                 const histNotification = protocolMsg.historySyncNotification;
@@ -135,21 +164,13 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                     isLatest
                 }, 'got history notification');
                 if (process) {
-                    // TODO: investigate
                     if (histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND) {
-                        ev.emit('creds.update', {
-                            processedHistoryMessages: [
-                                ...(creds.processedHistoryMessages || []),
-                                { key: message.key, messageTimestamp: message.messageTimestamp }
-                            ]
-                        });
+                        ev.emit('creds.update', { processedHistoryMessages: [...(creds.processedHistoryMessages || []), { key: message.key, messageTimestamp: message.messageTimestamp }] });
                     }
                     const data = await downloadAndProcessHistorySyncNotification(histNotification, options);
-                    ev.emit('messaging-history.set', {
-                        ...data,
-                        isLatest: histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND ? isLatest : undefined,
-                        peerDataRequestSessionId: histNotification.peerDataRequestSessionId
-                    });
+                    if (data.lidPnMappings?.length) { logger?.debug({ count: data.lidPnMappings.length }, 'processing LID-PN mappings from history sync'); await signalRepository.lidMapping.storeLIDPNMappings(data.lidPnMappings).catch(err => logger?.warn({ err }, 'failed to store LID-PN mappings from history sync')) }
+                    await storeTcTokensFromHistorySync(data.chats, signalRepository, keyStore, logger)
+                    ev.emit('messaging-history.set', { ...data, isLatest: histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND ? isLatest : undefined, chunkOrder: histNotification.chunkOrder, peerDataRequestSessionId: histNotification.peerDataRequestSessionId });
                 }
                 break;
             case proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE:
@@ -192,24 +213,21 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             case proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE:
                 const response = protocolMsg.peerDataOperationRequestResponseMessage;
                 if (response) {
-                    await placeholderResendCache?.del(response.stanzaId);
-                    // TODO: IMPLEMENT HISTORY SYNC ETC (sticker uploads etc.).
-                    const { peerDataOperationResult } = response;
+                    const peerDataOperationResult = response.peerDataOperationResult || []
                     for (const result of peerDataOperationResult) {
-                        const { placeholderMessageResendResponse: retryResponse } = result;
-                        //eslint-disable-next-line max-depth
-                        if (retryResponse) {
-                            const webMessageInfo = proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes);
-                            // wait till another upsert event is available, don't want it to be part of the PDO response message
-                            // TODO: parse through proper message handling utilities (to add relevant key fields)
-                            setTimeout(() => {
-                                ev.emit('messages.upsert', {
-                                    messages: [webMessageInfo],
-                                    type: 'notify',
-                                    requestId: response.stanzaId
-                                });
-                            }, 500);
-                        }
+                        const retryResponse = result?.placeholderMessageResendResponse
+                        if (!retryResponse?.webMessageInfoBytes) continue
+                        try {
+                            const webMessageInfo = proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes)
+                            const msgId = webMessageInfo.key?.id
+                            const cachedData = msgId ? await placeholderResendCache?.get(msgId) : undefined
+                            if (msgId) await placeholderResendCache?.del(msgId)
+                            let finalMsg
+                            if (cachedData && typeof cachedData === 'object') { cachedData.message = webMessageInfo.message; if (webMessageInfo.messageTimestamp) cachedData.messageTimestamp = webMessageInfo.messageTimestamp; finalMsg = cachedData }
+                            else finalMsg = webMessageInfo
+                            logger?.debug({ msgId, requestId: response.stanzaId }, 'received placeholder resend')
+                            ev.emit('messages.upsert', { messages: [finalMsg], type: 'notify', requestId: response.stanzaId })
+                        } catch (err) { logger?.warn({ err, stanzaId: response.stanzaId }, 'failed to decode placeholder resend response') }
                     }
                 }
                 break;

package/lib/Utils/reporting-utils.js

@@ -0,0 +1,155 @@
+import { createHmac } from 'crypto'
+import { hkdf } from './crypto.js'
+
+const reportingFields = [
+    { f: 1 },
+    { f: 3, s: [{ f: 2 }, { f: 3 }, { f: 8 }, { f: 11 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 25 }] },
+    { f: 4, s: [{ f: 1 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 5, s: [{ f: 3 }, { f: 4 }, { f: 5 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 6, s: [{ f: 1 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 30 }] },
+    { f: 7, s: [{ f: 2 }, { f: 7 }, { f: 10 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 8, s: [{ f: 2 }, { f: 7 }, { f: 9 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 21 }] },
+    { f: 9, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 12, s: [{ f: 1 }, { f: 2 }, { f: 14, m: true }, { f: 15 }] },
+    { f: 18, s: [{ f: 6 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 26, s: [{ f: 4 }, { f: 5 }, { f: 8 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 28, s: [{ f: 1 }, { f: 2 }, { f: 4 }, { f: 5 }, { f: 6 }, { f: 7, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 37, s: [{ f: 1, m: true }] },
+    { f: 49, s: [{ f: 2 }, { f: 3, s: [{ f: 1 }, { f: 2 }] }, { f: 5, s: [{ f: 21 }, { f: 22 }] }, { f: 8, s: [{ f: 1 }, { f: 2 }] }] },
+    { f: 53, s: [{ f: 1, m: true }] },
+    { f: 55, s: [{ f: 1, m: true }] },
+    { f: 58, s: [{ f: 1, m: true }] },
+    { f: 59, s: [{ f: 1, m: true }] },
+    { f: 60, s: [{ f: 2 }, { f: 3, s: [{ f: 1 }, { f: 2 }] }, { f: 5, s: [{ f: 21 }, { f: 22 }] }, { f: 8, s: [{ f: 1 }, { f: 2 }] }] },
+    { f: 64, s: [{ f: 2 }, { f: 3, s: [{ f: 1 }, { f: 2 }] }, { f: 5, s: [{ f: 21 }, { f: 22 }] }, { f: 8, s: [{ f: 1 }, { f: 2 }] }] },
+    { f: 66, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 74, s: [{ f: 1, m: true }] },
+    { f: 87, s: [{ f: 1, m: true }] },
+    { f: 88, s: [{ f: 1 }, { f: 2, s: [{ f: 1 }] }, { f: 3, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 92, s: [{ f: 1, m: true }] },
+    { f: 93, s: [{ f: 1, m: true }] },
+    { f: 94, s: [{ f: 1, m: true }] }
+]
+
+const EMPTY_MAP = new Map()
+const ENC_SECRET_REPORT_TOKEN = 'Report Token'
+const WIRE = { VARINT: 0, FIXED64: 1, BYTES: 2, FIXED32: 5 }
+
+const compileReportingFields = (fields) => {
+    const map = new Map()
+    for (const f of fields) map.set(f.f, { m: f.m, children: f.s ? compileReportingFields(f.s) : undefined })
+    return map
+}
+
+const compiledReportingFields = compileReportingFields(reportingFields)
+
+const decodeVarint = (buffer, offset) => {
+    let value = 0, bytes = 0, shift = 0
+    while (offset + bytes < buffer.length) {
+        const current = buffer[offset + bytes]
+        value |= (current & 0x7f) << shift
+        bytes++
+        if ((current & 0x80) === 0) return { value, bytes, ok: true }
+        shift += 7
+        if (shift > 35) return { value: 0, bytes: 0, ok: false }
+    }
+    return { value: 0, bytes: 0, ok: false }
+}
+
+const encodeVarint = (value) => {
+    const parts = []
+    let remaining = value >>> 0
+    while (remaining > 0x7f) { parts.push((remaining & 0x7f) | 0x80); remaining >>>= 7 }
+    parts.push(remaining)
+    return Buffer.from(parts)
+}
+
+const extractReportingTokenContent = (data, cfg) => {
+    const out = []
+    let i = 0
+    while (i < data.length) {
+        const tag = decodeVarint(data, i)
+        if (!tag.ok) return null
+        const fieldNum = tag.value >> 3
+        const wireType = tag.value & 0x7
+        const fieldStart = i
+        i += tag.bytes
+        const fieldCfg = cfg.get(fieldNum)
+        const pushSlice = (end) => { if (end > data.length) return false; out.push({ num: fieldNum, bytes: data.subarray(fieldStart, end) }); i = end; return true }
+        const skip = (end) => { if (end > data.length) return false; i = end; return true }
+        if (wireType === WIRE.VARINT) {
+            const v = decodeVarint(data, i)
+            if (!v.ok) return null
+            const end = i + v.bytes
+            if (!fieldCfg) { if (!skip(end)) return null; continue }
+            if (!pushSlice(end)) return null
+            continue
+        }
+        if (wireType === WIRE.FIXED64) {
+            const end = i + 8
+            if (!fieldCfg) { if (!skip(end)) return null; continue }
+            if (!pushSlice(end)) return null
+            continue
+        }
+        if (wireType === WIRE.FIXED32) {
+            const end = i + 4
+            if (!fieldCfg) { if (!skip(end)) return null; continue }
+            if (!pushSlice(end)) return null
+            continue
+        }
+        if (wireType === WIRE.BYTES) {
+            const len = decodeVarint(data, i)
+            if (!len.ok) return null
+            const valStart = i + len.bytes
+            const valEnd = valStart + len.value
+            if (valEnd > data.length) return null
+            if (!fieldCfg) { i = valEnd; continue }
+            if (fieldCfg.m || fieldCfg.children) {
+                const sub = extractReportingTokenContent(data.subarray(valStart, valEnd), fieldCfg.children ?? EMPTY_MAP)
+                if (sub === null) return null
+                if (sub.length > 0) {
+                    const newTag = encodeVarint(tag.value)
+                    const newLen = encodeVarint(sub.length)
+                    out.push({ num: fieldNum, bytes: Buffer.concat([newTag, newLen, sub]) })
+                }
+                i = valEnd
+                continue
+            }
+            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, valEnd) })
+            i = valEnd
+            continue
+        }
+        return null
+    }
+    if (out.length === 0) return Buffer.alloc(0)
+    out.sort((a, b) => a.num - b.num)
+    return Buffer.concat(out.map(f => f.bytes))
+}
+
+const generateMsgSecretKey = (modificationType, origMsgId, origMsgSender, modificationSender, origMsgSecret) => {
+    const useCaseSecret = Buffer.concat([
+        Buffer.from(origMsgId, 'utf8'), Buffer.from(origMsgSender, 'utf8'),
+        Buffer.from(modificationSender, 'utf8'), Buffer.from(modificationType, 'utf8')
+    ])
+    return hkdf(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') })
+}
+
+export const shouldIncludeReportingToken = (message) =>
+    !message.reactionMessage && !message.encReactionMessage &&
+    !message.encEventResponseMessage && !message.pollUpdateMessage
+
+export const getMessageReportingToken = async (msgProtobuf, message, key) => {
+    const msgSecret = message.messageContextInfo?.messageSecret
+    if (!msgSecret || !key.id) return null
+    const from = key.fromMe ? key.remoteJid : key.participant || key.remoteJid
+    const to = key.fromMe ? key.participant || key.remoteJid : key.remoteJid
+    const reportingSecret = generateMsgSecretKey(ENC_SECRET_REPORT_TOKEN, key.id, from, to, msgSecret)
+    const content = extractReportingTokenContent(msgProtobuf, compiledReportingFields)
+    if (!content || content.length === 0) return null
+    const reportingToken = createHmac('sha256', reportingSecret).update(content).digest().subarray(0, 16)
+    return {
+        tag: 'reporting',
+        attrs: {},
+        content: [{ tag: 'reporting_token', attrs: { v: '2' }, content: reportingToken }]
+    }
+}

package/lib/Utils/signal.js

@@ -1,43 +1,36 @@
-import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
-import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from '../WABinary/index.js';
-import { Curve, generateSignalPubKey } from './crypto.js';
-import { encodeBigEndian } from './generics.js';
-function chunk(array, size) {
-    const chunks = [];
-    for (let i = 0; i < array.length; i += size) {
-        chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
+import { KEY_BUNDLE_TYPE } from '../Defaults/index.js'
+import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from '../WABinary/index.js'
+import { Curve, generateSignalPubKey } from './crypto.js'
+import { encodeBigEndian } from './generics.js'
+
+const chunk = (array, size) => {
+    const chunks = []
+    for (let i = 0; i < array.length; i += size) chunks.push(array.slice(i, i + size))
+    return chunks
 }
-export const createSignalIdentity = (wid, accountSignatureKey) => {
-    return {
-        identifier: { name: wid, deviceId: 0 },
-        identifierKey: generateSignalPubKey(accountSignatureKey)
-    };
-};
+
+export const createSignalIdentity = (wid, accountSignatureKey) => ({
+    identifier: { name: wid, deviceId: 0 },
+    identifierKey: generateSignalPubKey(accountSignatureKey)
+})
+
 export const getPreKeys = async ({ get }, min, limit) => {
-    const idList = [];
-    for (let id = min; id < limit; id++) {
-        idList.push(id.toString());
-    }
-    return get('pre-key', idList);
-};
+    const idList = []
+    for (let id = min; id < limit; id++) idList.push(id.toString())
+    return get('pre-key', idList)
+}
+
 export const generateOrGetPreKeys = (creds, range) => {
-    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
-    const remaining = range - avaliable;
-    const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
-    const newPreKeys = {};
+    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
+    const remaining = range - avaliable
+    const lastPreKeyId = creds.nextPreKeyId + remaining - 1
+    const newPreKeys = {}
     if (remaining > 0) {
-        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = Curve.generateKeyPair();
-        }
+        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) newPreKeys[i] = Curve.generateKeyPair()
     }
-    return {
-        newPreKeys,
-        lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
-    };
-};
+    return { newPreKeys, lastPreKeyId, preKeysRange: [creds.firstUnuploadedPreKeyId, range] }
+}
+
 export const xmppSignedPreKey = (key) => ({
     tag: 'skey',
     attrs: {},
@@ -46,7 +39,8 @@ export const xmppSignedPreKey = (key) => ({
         { tag: 'value', attrs: {}, content: key.keyPair.public },
         { tag: 'signature', attrs: {}, content: key.signature }
     ]
-});
+})
+
 export const xmppPreKey = (pair, id) => ({
     tag: 'key',
     attrs: {},
@@ -54,100 +48,137 @@ export const xmppPreKey = (pair, id) => ({
         { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
         { tag: 'value', attrs: {}, content: pair.public }
     ]
-});
+})
+
+const isValidUInt = (n) => typeof n === 'number' && Number.isInteger(n) && n >= 0
+
+/**
+ * Extract a full E2E session bundle from a retry receipt's <keys> node.
+ * Returns null if the bundle is missing, malformed, or fails any integrity check.
+ * Used in sendMessagesAgain to inject the sender's fresh session on retry.
+ */
+export const extractE2ESessionFromRetryReceipt = (receipt) => {
+    const keysNode = getBinaryNodeChild(receipt, 'keys')
+    if (!keysNode) return null
+
+    const typeBuf = getBinaryNodeChildBuffer(keysNode, 'type')
+    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0]) return null
+
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity')
+    const skey = getBinaryNodeChild(keysNode, 'skey')
+    if (!identity || identity.length !== 32 || !skey) return null
+
+    const registrationId = getBinaryNodeChildUInt(receipt, 'registration', 4)
+    if (!isValidUInt(registrationId)) return null
+
+    const signedPubKey = getBinaryNodeChildBuffer(skey, 'value')
+    const signedSig = getBinaryNodeChildBuffer(skey, 'signature')
+    const signedKeyId = getBinaryNodeChildUInt(skey, 'id', 3)
+    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) return null
+
+    const preKeyNode = getBinaryNodeChild(keysNode, 'key')
+    let preKey
+    if (preKeyNode) {
+        const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, 'value')
+        const preKeyId = getBinaryNodeChildUInt(preKeyNode, 'id', 3)
+        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) return null
+        preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) }
+    }
+
+    return {
+        registrationId,
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: { keyId: signedKeyId, publicKey: generateSignalPubKey(signedPubKey), signature: signedSig },
+        preKey
+    }
+}
+
+/**
+ * Parse and inject E2E sessions from a server key response node.
+ * Unlike upstream, we filter error nodes individually so one bad user
+ * never aborts the entire batch — all valid sessions still get injected.
+ * CPU-heavy work is chunked in groups of 100 to yield to the event loop between batches.
+ */
 export const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = (key) => key
-        ? {
-            keyId: getBinaryNodeChildUInt(key, 'id', 3),
-            publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
-            signature: getBinaryNodeChildBuffer(key, 'signature')
-        }
-        : undefined;
+    const extractKey = (key) => key ? {
+        keyId: getBinaryNodeChildUInt(key, 'id', 3),
+        publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
+        signature: getBinaryNodeChildBuffer(key, 'signature')
+    } : undefined
+
     const allNodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user')
-    // Filter out error nodes individually instead of aborting everything
     const nodes = allNodes.filter(node => {
         try { assertNodeErrorFree(node); return true }
         catch { return false }
     })
-    // Most of the work in repository.injectE2ESession is CPU intensive, not IO
-    // So Promise.all doesn't really help here,
-    // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
-    // This way we chunk it in smaller parts and between those parts we can yield to the event loop
-    // It's rare case when you need to E2E sessions for so many users, but it's possible
-    const chunkSize = 100;
-    const chunks = chunk(nodes, chunkSize);
+
+    const chunks = chunk(nodes, 100)
     for (const nodesChunk of chunks) {
         for (const node of nodesChunk) {
-            const signedKey = getBinaryNodeChild(node, 'skey');
-            const key = getBinaryNodeChild(node, 'key');
-            const identity = getBinaryNodeChildBuffer(node, 'identity');
-            const jid = node.attrs.jid;
-            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4);
+            const signedKey = getBinaryNodeChild(node, 'skey')
+            const key = getBinaryNodeChild(node, 'key')
+            const identity = getBinaryNodeChildBuffer(node, 'identity')
+            const jid = node.attrs.jid
+            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4)
             await repository.injectE2ESession({
                 jid,
                 session: {
-                    registrationId: registrationId,
+                    registrationId,
                     identityKey: generateSignalPubKey(identity),
                     signedPreKey: extractKey(signedKey),
                     preKey: extractKey(key)
                 }
-            });
+            })
         }
+        // Yield to event loop between chunks to avoid blocking on large batches
+        await new Promise(resolve => setImmediate(resolve))
     }
-};
+}
+
+/**
+ * Extract device JIDs from a USync result list.
+ * Skips your own current device, respects excludeZeroDevices flag,
+ * and correctly resolves hosted LID/PN domain types.
+ */
 export const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = jidDecode(myJid);
-    const extracted = [];
+    const { user: myUser, device: myDevice } = jidDecode(myJid)
+    const extracted = []
     for (const userResult of result) {
-        const { devices, id } = userResult;
-        const decoded = jidDecode(id), { user, server } = decoded;
-        let { domainType } = decoded;
-        const deviceList = devices?.deviceList;
-        if (!Array.isArray(deviceList))
-            continue;
+        const { devices, id } = userResult
+        const decoded = jidDecode(id)
+        const { user, server } = decoded
+        let { domainType } = decoded
+        const deviceList = devices?.deviceList
+        if (!Array.isArray(deviceList)) continue
         for (const { id: device, keyIndex, isHosted } of deviceList) {
-            if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
-                ((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
-                (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-            ) {
-                if (isHosted) {
-                    domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
-                }
-                extracted.push({
-                    user,
-                    device,
-                    domainType,
-                    server: getServerFromDomainType(server, domainType)
-                });
+            if ((!excludeZeroDevices || device !== 0) &&
+                ((myUser !== user && myLid !== user) || myDevice !== device) &&
+                (device === 0 || !!keyIndex)) {
+                if (isHosted) domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED
+                extracted.push({ user, device, domainType, server: getServerFromDomainType(server, domainType) })
             }
         }
     }
-    return extracted;
-};
-/**
- * get the next N keys for upload or processing
- * @param count number of pre-keys to get or generate
- */
+    return extracted
+}
+
 export const getNextPreKeys = async ({ creds, keys }, count) => {
-    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count);
+    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count)
     const update = {
         nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
         firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
-    };
-    await keys.set({ 'pre-key': newPreKeys });
-    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
-    return { update, preKeys };
-};
+    }
+    await keys.set({ 'pre-key': newPreKeys })
+    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
+    return { update, preKeys }
+}
+
 export const getNextPreKeysNode = async (state, count) => {
-    const { creds } = state;
-    const { update, preKeys } = await getNextPreKeys(state, count);
+    const { creds } = state
+    const { update, preKeys } = await getNextPreKeys(state, count)
     const node = {
         tag: 'iq',
-        attrs: {
-            xmlns: 'encrypt',
-            type: 'set',
-            to: S_WHATSAPP_NET
-        },
+        attrs: { xmlns: 'encrypt', type: 'set', to: S_WHATSAPP_NET },
         content: [
             { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
             { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
@@ -155,7 +186,6 @@ export const getNextPreKeysNode = async (state, count) => {
             { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
             xmppSignedPreKey(creds.signedPreKey)
         ]
-    };
-    return { update, node };
-};
-//# sourceMappingURL=signal.js.map
+    }
+    return { update, node }
+}

package/lib/Utils/sync-action-utils.js

@@ -0,0 +1,33 @@
+import { isLidUser, isPnUser } from '../WABinary/index.js'
+
+export const processContactAction = (action, id, logger) => {
+    const results = []
+    if (!id) {
+        logger?.warn({ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid }, 'contactAction sync: missing id in index')
+        return results
+    }
+    const lidJid = action.lidJid
+    const idIsPn = isPnUser(id)
+    const phoneNumber = idIsPn ? id : action.pnJid || undefined
+    results.push({
+        event: 'contacts.upsert',
+        data: [{
+            id,
+            name: action.fullName || action.firstName || action.username || undefined,
+            username: action.username || undefined,
+            lid: lidJid || undefined,
+            phoneNumber
+        }]
+    })
+    if (lidJid && isLidUser(lidJid) && idIsPn) {
+        results.push({ event: 'lid-mapping.update', data: { lid: lidJid, pn: id } })
+    }
+    return results
+}
+
+export const emitSyncActionResults = (ev, results) => {
+    for (const result of results) {
+        if (result.event === 'contacts.upsert') ev.emit('contacts.upsert', result.data)
+        else ev.emit('lid-mapping.update', result.data)
+    }
+}