@badzz88/baileys 8.5.3 → 8.5.4

package/lib/Utils/process-message.js

@@ -59,9 +59,9 @@ const REAL_MSG_STUB_TYPES = new Set([
 	Types_1.WAMessageStubType.CALL_MISSED_VOICE
 ])
 const REAL_MSG_REQ_ME_STUB_TYPES = new Set([Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD])
-/** Cleans a received message to further processing */
+
 const cleanMessage = (message, meId, meLid) => {
-	// ensure remoteJid and participant doesn't have device or agent in it
+	
 	if ((0, WABinary_1.isHostedPnUser)(message.key.remoteJid) || (0, WABinary_1.isHostedLidUser)(message.key.remoteJid)) {
 		message.key.remoteJid = (0, WABinary_1.jidEncode)(
 			(0, WABinary_1.jidDecode)(message.key?.remoteJid)?.user,
@@ -82,7 +82,7 @@ const cleanMessage = (message, meId, meLid) => {
 		message.key.participant = (0, WABinary_1.jidNormalizedUser)(message.key.participant)
 	}
 	const content = (0, messages_1.normalizeMessageContent)(message.message)
-	// if the message has a reaction, ensure fromMe & remoteJid are from our perspective
+	
 	if (content?.reactionMessage) {
 		normaliseKey(content.reactionMessage.key)
 	}
@@ -90,47 +90,48 @@ const cleanMessage = (message, meId, meLid) => {
 		normaliseKey(content.pollUpdateMessage.pollCreationMessageKey)
 	}
 	function normaliseKey(msgKey) {
-		// if the reaction is from another user
-		// we've to correctly map the key to this user's perspective
+		
+		
 		if (!message.key.fromMe) {
-			// if the sender believed the message being reacted to is not from them
-			// we've to correct the key to be from them, or some other participant
+			
+			
 			msgKey.fromMe = !msgKey.fromMe
 				? (0, WABinary_1.areJidsSameUser)(msgKey.participant || msgKey.remoteJid, meId) ||
 					(0, WABinary_1.areJidsSameUser)(msgKey.participant || msgKey.remoteJid, meLid)
-				: // if the message being reacted to, was from them
-					// fromMe automatically becomes false
+				: 
+					
 					false
-			// set the remoteJid to being the same as the chat the message came from
-			// TODO: investigate inconsistencies
+			
+			
 			msgKey.remoteJid = message.key.remoteJid
-			// set participant of the message
+			
 			msgKey.participant = msgKey.participant || message.key.participant
 		}
 	}
 }
 exports.cleanMessage = cleanMessage
-// TODO: target:audit AUDIT THIS FUNCTION AGAIN
 const isRealMessage = message => {
+	
+	
+	
+	if (REAL_MSG_STUB_TYPES.has(message.messageStubType) || REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType)) {
+		return true
+	}
 	const normalizedContent = (0, messages_1.normalizeMessageContent)(message.message)
 	const hasSomeContent = !!(0, messages_1.getContentType)(normalizedContent)
 	return (
-		(!!normalizedContent ||
-			REAL_MSG_STUB_TYPES.has(message.messageStubType) ||
-			REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType)) &&
+		!!normalizedContent &&
 		hasSomeContent &&
 		!normalizedContent?.protocolMessage &&
 		!normalizedContent?.reactionMessage &&
-		!normalizedContent?.pollUpdateMessage
+		!normalizedContent?.pollUpdateMessage &&
+		!normalizedContent?.secretEncryptedMessage
 	)
 }
 exports.isRealMessage = isRealMessage
 const shouldIncrementChatUnread = message => !message.key.fromMe && !message.messageStubType
 exports.shouldIncrementChatUnread = shouldIncrementChatUnread
-/**
- * Get the ID of the chat from the given key.
- * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
- */
+
 const getChatId = ({ remoteJid, participant, fromMe }) => {
 	if ((0, WABinary_1.isJidBroadcast)(remoteJid) && !(0, WABinary_1.isJidStatusBroadcast)(remoteJid) && !fromMe) {
 		return participant
@@ -138,12 +139,7 @@ const getChatId = ({ remoteJid, participant, fromMe }) => {
 	return remoteJid
 }
 exports.getChatId = getChatId
-/**
- * Decrypt a poll vote
- * @param vote encrypted vote
- * @param ctx additional info about the poll required for decryption
- * @returns list of SHA256 options
- */
+
 function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pollEncKey, voterJid }) {
 	const sign = Buffer.concat([
 		toBinary(pollMsgId),
@@ -161,12 +157,7 @@ function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pol
 		return Buffer.from(txt)
 	}
 }
-/**
- * Decrypt an event response
- * @param response encrypted event response
- * @param ctx additional info about the event required for decryption
- * @returns event response message
- */
+
 function decryptEventResponse({ encPayload, encIv }, { eventCreatorJid, eventMsgId, eventEncKey, responderJid }) {
 	const sign = Buffer.concat([
 		toBinary(eventMsgId),
@@ -184,6 +175,108 @@ function decryptEventResponse({ encPayload, encIv }, { eventCreatorJid, eventMsg
 		return Buffer.from(txt)
 	}
 }
+
+function decryptMessageEdit({ encPayload, encIv }, { origMsgId, origMsgSenderJid, editorJid, msgEncKey }) {
+	const sign = Buffer.concat([
+		toBinary(origMsgId),
+		toBinary(origMsgSenderJid),
+		toBinary(editorJid),
+		toBinary('Message Edit'),
+		new Uint8Array([1])
+	])
+	const key0 = (0, crypto_1.hmacSign)(msgEncKey, new Uint8Array(32), 'sha256')
+	const decKey = (0, crypto_1.hmacSign)(sign, key0, 'sha256')
+	
+	const decrypted = (0, crypto_1.aesDecryptGCM)(encPayload, decKey, encIv, new Uint8Array(0))
+	return index_js_1.proto.Message.decode(decrypted)
+	function toBinary(txt) {
+		return Buffer.from(txt)
+	}
+}
+exports.decryptMessageEdit = decryptMessageEdit
+
+const unwrapSecretEncryptedMessage = async (message, { creds, getMessage, logger }) => {
+	const content = (0, messages_1.normalizeMessageContent)(message.message)
+	const secretEnc = content?.secretEncryptedMessage
+	if (
+		!secretEnc?.encPayload ||
+		!secretEnc.encIv ||
+		secretEnc.secretEncType !== index_js_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT
+	) {
+		return
+	}
+	const targetKey = secretEnc.targetMessageKey
+	if (!targetKey?.id) {
+		return
+	}
+	try {
+		
+		
+		const origMsg = await getMessage({
+			...targetKey,
+			remoteJid: message.key.remoteJid,
+			fromMe: message.key.fromMe,
+			participant: message.key.participant
+		})
+		let msgEncKey = origMsg?.messageContextInfo?.messageSecret
+		if (typeof msgEncKey === 'string') {
+			
+			msgEncKey = Buffer.from(msgEncKey, 'base64')
+		}
+		if (!msgEncKey?.length) {
+			logger?.warn({ targetKey }, 'message edit: missing messageSecret for decryption')
+			return
+		}
+		
+		
+		const meIdNormalised = (0, WABinary_1.jidNormalizedUser)(creds.me.id)
+		const candidates = [
+			...(message.key.fromMe
+				? [meIdNormalised, creds.me?.lid]
+				: [message.key.participant || message.key.remoteJid, message.key.participantAlt || message.key.remoteJidAlt]),
+			targetKey.remoteJid
+		]
+			.filter(jid => !!jid)
+			.map(jid => (0, WABinary_1.jidNormalizedUser)(jid))
+			.filter((jid, i, arr) => arr.indexOf(jid) === i)
+		let decoded
+		let lastError
+		for (const authorJid of candidates) {
+			try {
+				decoded = decryptMessageEdit(secretEnc, {
+					origMsgId: targetKey.id,
+					origMsgSenderJid: authorJid,
+					editorJid: authorJid,
+					msgEncKey
+				})
+				break
+			} catch (err) {
+				lastError = err
+			}
+		}
+		if (!decoded) {
+			throw lastError
+		}
+		if (!decoded.protocolMessage) {
+			
+			decoded = index_js_1.proto.Message.fromObject({
+				protocolMessage: {
+					key: targetKey,
+					type: index_js_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
+					editedMessage: decoded
+				}
+			})
+		}
+		if (!decoded.messageContextInfo && content?.messageContextInfo) {
+			decoded.messageContextInfo = content.messageContextInfo
+		}
+		message.message = decoded
+		logger?.debug({ targetKey }, 'decrypted secretEncryptedMessage edit')
+	} catch (err) {
+		logger?.warn({ err, targetKey }, 'failed to decrypt secretEncryptedMessage edit')
+	}
+}
+exports.unwrapSecretEncryptedMessage = unwrapSecretEncryptedMessage
 const processMessage = async (
 	message,
 	{
@@ -205,7 +298,7 @@ const processMessage = async (
 	if (isRealMsg) {
 		chat.messages = [{ message }]
 		chat.conversationTimestamp = (0, generics_1.toNumber)(message.messageTimestamp)
-		// only increment unread count if not CIPHERTEXT and from another person
+		
 		if ((0, exports.shouldIncrementChatUnread)(message)) {
 			chat.unreadCount = (chat.unreadCount || 0) + 1
 		}
@@ -236,8 +329,8 @@ const processMessage = async (
 		})
 	}
 	const content = (0, messages_1.normalizeMessageContent)(message.message)
-	// unarchive chat if it's a real message, or someone reacted to our message
-	// and we've the unarchive chats setting on
+	
+	
 	if ((isRealMsg || content?.reactionMessage?.key?.fromMe) && accountSettings?.unarchiveChats) {
 		chat.archived = false
 		chat.readOnly = false
@@ -259,7 +352,7 @@ const processMessage = async (
 					'got history notification'
 				)
 				if (process) {
-					// TODO: investigate
+					
 					if (histNotification.syncType !== index_js_1.proto.HistorySync.HistorySyncType.ON_DEMAND) {
 						ev.emit('creds.update', {
 							processedHistoryMessages: [
@@ -325,31 +418,31 @@ const processMessage = async (
 			case index_js_1.proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE:
 				const response = protocolMsg.peerDataOperationRequestResponseMessage
 				if (response) {
-					// TODO: IMPLEMENT HISTORY SYNC ETC (sticker uploads etc.).
+					
 					const peerDataOperationResult = response.peerDataOperationResult || []
 					for (const result of peerDataOperationResult) {
 						const retryResponse = result?.placeholderMessageResendResponse
-						//eslint-disable-next-line max-depth
+						
 						if (!retryResponse?.webMessageInfoBytes) {
 							continue
 						}
-						//eslint-disable-next-line max-depth
+						
 						try {
 							const webMessageInfo = index_js_1.proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes)
 							const msgId = webMessageInfo.key?.id
-							// Retrieve cached original message data (preserves LID details,
-							// timestamps, etc. that the phone may omit in its PDO response)
+							
+							
 							const cachedData = msgId ? await placeholderResendCache?.get(msgId) : undefined
-							//eslint-disable-next-line max-depth
+							
 							if (msgId) {
 								await placeholderResendCache?.del(msgId)
 							}
 							let finalMsg
-							//eslint-disable-next-line max-depth
+							
 							if (cachedData && typeof cachedData === 'object') {
-								// Apply decoded message content onto cached metadata (preserves LID etc.)
+								
 								cachedData.message = webMessageInfo.message
-								//eslint-disable-next-line max-depth
+								
 								if (webMessageInfo.messageTimestamp) {
 									cachedData.messageTimestamp = webMessageInfo.messageTimestamp
 								}
@@ -372,7 +465,7 @@ const processMessage = async (
 			case index_js_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT:
 				ev.emit('messages.update', [
 					{
-						// flip the sender / fromMe properties because they're in the perspective of the sender
+						
 						key: { ...message.key, id: protocolMsg.key?.id },
 						update: {
 							message: {
@@ -389,10 +482,12 @@ const processMessage = async (
 				break
 			case index_js_1.proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE:
 				const labelAssociationMsg = protocolMsg.memberLabel
-				if (labelAssociationMsg?.label) {
+				if (labelAssociationMsg) {
+					
+					
 					ev.emit('group.member-tag.update', {
 						groupId: chat.id,
-						label: labelAssociationMsg.label,
+						label: labelAssociationMsg.label || '',
 						participant: message.key.participant,
 						participantAlt: message.key.participantAlt,
 						messageTimestamp: Number(message.messageTimestamp)
@@ -616,12 +711,12 @@ const processMessage = async (
 	} else if (content?.encEventResponseMessage) {
 		const encEventResponse = content.encEventResponseMessage
 		const creationMsgKey = encEventResponse.eventCreationMessageKey
-		// we need to fetch the event creation message to get the event enc key
+		
 		const eventMsg = await getMessage(creationMsgKey)
 		if (eventMsg) {
 			try {
 				const meIdNormalised = (0, WABinary_1.jidNormalizedUser)(meId)
-				// all jids need to be PN
+				
 				const eventCreatorKey = creationMsgKey.participant || creationMsgKey.remoteJid
 				const eventCreatorPn = (0, WABinary_1.isLidUser)(eventCreatorKey)
 					? await signalRepository.lidMapping.getPNForLID(eventCreatorKey)
@@ -663,7 +758,7 @@ const processMessage = async (
 		}
 	} else if (message.messageStubType) {
 		const jid = message.key?.remoteJid
-		//let actor = whatsappID (message.participant)
+		
 		let participants
 		const emitParticipantsUpdate = action =>
 			ev.emit('group-participants.update', {
@@ -679,7 +774,7 @@ const processMessage = async (
 				{
 					id: jid,
 					...update,
-					author: message.key.participant ?? undefined,
+					author: message.key.participant,
 					authorPn: message.key.participantAlt,
 					authorUsername: message.key.participantUsername
 				}
@@ -698,7 +793,7 @@ const processMessage = async (
 			})
 		}
 		const participantsIncludesMe = () =>
-			participants.find(jid => (0, WABinary_1.areJidsSameUser)(meId, jid.phoneNumber)) // ADD SUPPORT FOR LID
+			participants.find(jid => (0, WABinary_1.areJidsSameUser)(meId, jid.phoneNumber)) 
 		switch (message.messageStubType) {
 			case Types_1.WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER:
 				participants = message.messageStubParameters.map(a => JSON.parse(a)) || []
@@ -708,7 +803,7 @@ const processMessage = async (
 			case Types_1.WAMessageStubType.GROUP_PARTICIPANT_REMOVE:
 				participants = message.messageStubParameters.map(a => JSON.parse(a)) || []
 				emitParticipantsUpdate('remove')
-				// mark the chat read only if you left the group
+				
 				if (participantsIncludesMe()) {
 					chat.readOnly = true
 				}
@@ -760,7 +855,7 @@ const processMessage = async (
 				const approvalMode = message.messageStubParameters?.[0]
 				emitGroupUpdate({ joinApprovalMode: approvalMode === 'on' })
 				break
-			case Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD: // TODO: Add other events
+			case Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD:
 				const participant = JSON.parse(message.messageStubParameters?.[0])
 				const action = message.messageStubParameters?.[1]
 				const method = message.messageStubParameters?.[2]
@@ -850,7 +945,7 @@ const processMessage = async (
 				ev.emit('chats.update', [{ id: jid, psa: { urlParams: message.messageStubParameters } }])
 				break
 			case Types_1.WAMessageStubType.CHAT_POLL_CREATION_MESSAGE:
-				// poll was created, no special action needed beyond message processing
+				
 				break
 			case Types_1.WAMessageStubType.BIZ_CHAT_ASSIGNMENT:
 				ev.emit('chats.update', [
@@ -992,55 +1087,51 @@ const processMessage = async (
 				emitGroupUpdate({ hidden: true })
 				break
 		}
-	} /*  else if(content?.pollUpdateMessage) {
-        const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey!
-        // we need to fetch the poll creation message to get the poll enc key
-        // TODO: make standalone, remove getMessage reference
-        // TODO: Remove entirely
-        const pollMsg = await getMessage(creationMsgKey)
-        if(pollMsg) {
-            const meIdNormalised = jidNormalizedUser(meId)
-            const pollCreatorJid = getKeyAuthor(creationMsgKey, meIdNormalised)
-            const voterJid = getKeyAuthor(message.key, meIdNormalised)
-            const pollEncKey = pollMsg.messageContextInfo?.messageSecret!
-
-            try {
-                const voteMsg = decryptPollVote(
-                    content.pollUpdateMessage.vote!,
-                    {
-                        pollEncKey,
-                        pollCreatorJid,
-                        pollMsgId: creationMsgKey.id!,
-                        voterJid,
-                    }
-                )
-                ev.emit('messages.update', [
-                    {
-                        key: creationMsgKey,
-                        update: {
-                            pollUpdates: [
-                                {
-                                    pollUpdateMessageKey: message.key,
-                                    vote: voteMsg,
-                                    senderTimestampMs: (content.pollUpdateMessage.senderTimestampMs! as Long).toNumber(),
-                                }
-                            ]
-                        }
-                    }
-                ])
-            } catch(err) {
-                logger?.warn(
-                    { err, creationMsgKey },
-                    'failed to decrypt poll vote'
-                )
-            }
-        } else {
-            logger?.warn(
-                { creationMsgKey },
-                'poll creation message not found, cannot decrypt update'
-            )
-        }
-        } */
+	} else if (content?.pollUpdateMessage) {
+		const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey
+		const pollMsg = await getMessage(creationMsgKey)
+		if (pollMsg) {
+			
+			const inner = pollMsg.viewOnceMessage?.message || pollMsg.botInvokeMessage?.message || pollMsg
+			const pollEncKey = inner.messageContextInfo?.messageSecret || pollMsg.messageContextInfo?.messageSecret || null
+			if (!pollEncKey) {
+				logger?.warn({ creationMsgKey }, 'poll: messageSecret missing, cannot decrypt vote')
+			} else {
+				
+				const rawLid = creds.me?.lid
+				const meLidNorm = rawLid ? `${rawLid.split(':')[0]}@lid` : ''
+				const pollCreatorJid = meLidNorm || (0, WABinary_1.jidNormalizedUser)(meId)
+				
+				const voterJid = message.key.fromMe ? pollCreatorJid : message.key.participant || message.key.remoteJid
+				try {
+					const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
+						pollEncKey,
+						pollCreatorJid,
+						pollMsgId: creationMsgKey.id,
+						voterJid
+					})
+					ev.emit('messages.update', [
+						{
+							key: creationMsgKey,
+							update: {
+								pollUpdates: [
+									{
+										pollUpdateMessageKey: message.key,
+										vote: voteMsg,
+										senderTimestampMs: (0, generics_1.toNumber)(content.pollUpdateMessage.senderTimestampMs)
+									}
+								]
+							}
+						}
+					])
+				} catch (err) {
+					logger?.warn({ err, creationMsgKey, pollCreatorJid, voterJid }, 'failed to decrypt poll vote')
+				}
+			}
+		} else {
+			logger?.warn({ creationMsgKey }, 'poll: creation message not found, cannot decrypt vote')
+		}
+	}
 	if (Object.keys(chat).length > 1) {
 		ev.emit('chats.update', [chat])
 	}

package/lib/Utils/reporting-utils.js

@@ -1,7 +1,7 @@
 'use strict'
 Object.defineProperty(exports, '__esModule', { value: true })
 exports.getMessageReportingToken = exports.shouldIncludeReportingToken = void 0
-const Crypto_1 = require('./crypto')
+const rb = require('whatsapp-rust-bridge')
 const crypto_2 = require('./crypto')
 const reportingFields = [
 	{ f: 1 },
@@ -246,7 +246,7 @@ const getMessageReportingToken = async (msgProtobuf, message, key) => {
 	if (!content || content.length === 0) {
 		return null
 	}
-	const reportingToken = Buffer.from(Crypto_1.hmacSign(content, reportingSecret)).subarray(0, 16)
+	const reportingToken = Buffer.from(rb.hmacSign(content, reportingSecret)).subarray(0, 16)
 	return {
 		tag: 'reporting',
 		attrs: {},

package/lib/Utils/signal.js

@@ -4,7 +4,6 @@ exports.getNextPreKeysNode =
 	exports.getNextPreKeys =
 	exports.extractDeviceJids =
 	exports.parseAndInjectE2ESessions =
-	exports.extractE2ESessionFromRetryReceipt =
 	exports.xmppPreKey =
 	exports.xmppSignedPreKey =
 	exports.generateOrGetPreKeys =
@@ -54,9 +53,11 @@ const generateOrGetPreKeys = (creds, range) => {
 	}
 }
 exports.generateOrGetPreKeys = generateOrGetPreKeys
-const xmppSignedPreKey = key => ({
+
+
+const xmppSignedPreKey = (key, cipherSuite) => ({
 	tag: 'skey',
-	attrs: {},
+	attrs: cipherSuite !== undefined ? { key_cipher_suite: cipherSuite } : {},
 	content: [
 		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
 		{ tag: 'value', attrs: {}, content: key.keyPair.public },
@@ -64,72 +65,36 @@ const xmppSignedPreKey = key => ({
 	]
 })
 exports.xmppSignedPreKey = xmppSignedPreKey
-const xmppPreKey = (pair, id) => ({
+const xmppPreKey = (pair, id, cipherSuite) => ({
 	tag: 'key',
-	attrs: {},
+	attrs: cipherSuite !== undefined ? { key_cipher_suite: cipherSuite } : {},
 	content: [
 		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
 		{ tag: 'value', attrs: {}, content: pair.public }
 	]
 })
 exports.xmppPreKey = xmppPreKey
-const isValidUInt = n => typeof n === 'number' && Number.isInteger(n)
-const extractE2ESessionFromRetryReceipt = receipt => {
-	const keysNode = (0, WABinary_1.getBinaryNodeChild)(receipt, 'keys')
-	if (!keysNode) return null
-	const typeBuf = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'type')
-	if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== Defaults_1.KEY_BUNDLE_TYPE[0]) return null
-	const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'identity')
-	const skey = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'skey')
-	if (!identity || identity.length !== 32 || !skey) return null
-	const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(receipt, 'registration', 4)
-	if (!isValidUInt(registrationId)) return null
-	const signedPubKey = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'value')
-	const signedSig = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'signature')
-	const signedKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(skey, 'id', 3)
-	if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
-		return null
-	}
-	const preKeyNode = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'key')
-	let preKey
-	if (preKeyNode) {
-		const preKeyPub = (0, WABinary_1.getBinaryNodeChildBuffer)(preKeyNode, 'value')
-		const preKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(preKeyNode, 'id', 3)
-		if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
-			return null
+const parseAndInjectE2ESessions = async (node, repository) => {
+	const extractKey = key => {
+		if (!key) return undefined
+		const cipherSuite = key.attrs?.key_cipher_suite
+		return {
+			keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
+			publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
+			signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature'),
+			
+			...(cipherSuite !== undefined ? { cipherSuite } : {})
 		}
-		preKey = { keyId: preKeyId, publicKey: (0, crypto_1.generateSignalPubKey)(preKeyPub) }
-	}
-	return {
-		registrationId,
-		identityKey: (0, crypto_1.generateSignalPubKey)(identity),
-		signedPreKey: {
-			keyId: signedKeyId,
-			publicKey: (0, crypto_1.generateSignalPubKey)(signedPubKey),
-			signature: signedSig
-		},
-		preKey
 	}
-}
-exports.extractE2ESessionFromRetryReceipt = extractE2ESessionFromRetryReceipt
-const parseAndInjectE2ESessions = async (node, repository) => {
-	const extractKey = key =>
-		key
-			? {
-					keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
-					publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
-					signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature')
-				}
-			: undefined
 	const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user')
 	for (const node of nodes) {
 		;(0, WABinary_1.assertNodeErrorFree)(node)
 	}
-	// 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)
 	for (const nodesChunk of chunks) {
@@ -164,9 +129,9 @@ const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
 		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
+				(!excludeZeroDevices || device !== 0) && 
+				((myUser !== user && myLid !== user) || myDevice !== device) && 
+				(device === 0 || !!keyIndex) 
 			) {
 				if (isHosted) {
 					domainType =
@@ -186,10 +151,7 @@ const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
 	return extracted
 }
 exports.extractDeviceJids = extractDeviceJids
-/**
- * get the next N keys for upload or processing
- * @param count number of pre-keys to get or generate
- */
+
 const getNextPreKeys = async ({ creds, keys }, count) => {
 	const { newPreKeys, lastPreKeyId, preKeysRange } = (0, exports.generateOrGetPreKeys)(creds, count)
 	const update = {
@@ -215,6 +177,9 @@ const getNextPreKeysNode = async (state, count) => {
 			{ tag: 'registration', attrs: {}, content: (0, generics_1.encodeBigEndian)(creds.registrationId) },
 			{ tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
 			{ tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
+			
+			
+			
 			{ tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
 			(0, exports.xmppSignedPreKey)(creds.signedPreKey)
 		]