@bellaxchuu/flowred 0.8.6

package/lib/Utils/reporting-utils.js

@@ -0,0 +1,262 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.getMessageReportingToken = exports.shouldIncludeReportingToken = void 0
+const Crypto_1 = require('./crypto')
+const crypto_2 = require('./crypto')
+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 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 EMPTY_MAP = new Map()
+const ENC_SECRET_REPORT_TOKEN = 'Report Token'
+const WIRE = {
+	VARINT: 0,
+	FIXED64: 1,
+	BYTES: 2,
+	FIXED32: 5
+}
+const shouldIncludeReportingToken = message =>
+	!message.reactionMessage &&
+	!message.encReactionMessage &&
+	!message.encEventResponseMessage &&
+	!message.pollUpdateMessage
+exports.shouldIncludeReportingToken = shouldIncludeReportingToken
+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 (0, crypto_2.hkdf)(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') })
+}
+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 decodeVarint = (buffer, offset) => {
+	let value = 0
+	let bytes = 0
+	let 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 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 = Buffer.from(Crypto_1.hmacSign(content, reportingSecret)).subarray(0, 16)
+	return {
+		tag: 'reporting',
+		attrs: {},
+		content: [
+			{
+				tag: 'reporting_token',
+				attrs: { v: '2' },
+				content: reportingToken
+			}
+		]
+	}
+}
+exports.getMessageReportingToken = getMessageReportingToken

package/lib/Utils/session-pool.js

@@ -0,0 +1,94 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.createSessionPool = void 0
+
+const DISCONNECT_REASON_LOGGED_OUT = 401
+
+/**
+ * Manages multiple Baileys socket instances (one per account/session), automatically
+ * restarting any session that disconnects -- except when it was logged out -- using
+ * exponential backoff with jitter, instead of every project re-implementing its own
+ * reconnect loop.
+ *
+ * @param {{
+ *   makeSocket: (sessionId: string) => Promise<any> | any,
+ *   logger?: any,
+ *   maxBackoffMs?: number,
+ *   onSessionUpdate?: (sessionId: string, sock: any) => void,
+ *   onLoggedOut?: (sessionId: string) => void
+ * }} options
+ * @returns {{
+ *   add: (sessionId: string) => Promise<void>,
+ *   remove: (sessionId: string) => void,
+ *   get: (sessionId: string) => any,
+ *   list: () => string[]
+ * }}
+ */
+const createSessionPool = options => {
+	const logger = options.logger
+	const maxBackoffMs = options.maxBackoffMs ?? 60000
+	const sessions = new Map() // sessionId -> { sock, attempts, stopped }
+
+	const computeBackoffMs = attempts => {
+		const base = Math.min(1000 * 2 ** attempts, maxBackoffMs)
+		return base + Math.floor(Math.random() * (base * 0.2))
+	}
+
+	const start = async sessionId => {
+		const entry = sessions.get(sessionId) || { attempts: 0, stopped: false }
+		sessions.set(sessionId, entry)
+		if (entry.stopped) return
+		try {
+			const sock = await options.makeSocket(sessionId)
+			entry.sock = sock
+			options.onSessionUpdate?.(sessionId, sock)
+			sock.ev.on('connection.update', update => {
+				if (update.connection === 'open') {
+					entry.attempts = 0
+				}
+				if (update.connection === 'close') {
+					const statusCode = update.lastDisconnect?.error?.output?.statusCode
+					if (statusCode === DISCONNECT_REASON_LOGGED_OUT) {
+						logger?.info?.({ sessionId }, 'session logged out, removing from pool')
+						sessions.delete(sessionId)
+						options.onLoggedOut?.(sessionId)
+						return
+					}
+					if (entry.stopped) return
+					entry.attempts += 1
+					const backoffMs = computeBackoffMs(entry.attempts)
+					logger?.warn?.(
+						{ sessionId, attempt: entry.attempts, backoffMs },
+						'session disconnected, reconnecting with backoff'
+					)
+					setTimeout(() => start(sessionId), backoffMs)
+				}
+			})
+		} catch (error) {
+			entry.attempts += 1
+			const backoffMs = computeBackoffMs(entry.attempts)
+			logger?.error?.({ error, sessionId, backoffMs }, 'failed to start session, retrying with backoff')
+			if (!entry.stopped) {
+				setTimeout(() => start(sessionId), backoffMs)
+			}
+		}
+	}
+
+	const add = sessionId => start(sessionId)
+	const remove = sessionId => {
+		const entry = sessions.get(sessionId)
+		if (!entry) return
+		entry.stopped = true
+		if (entry.sock?.end) {
+			try {
+				entry.sock.end(undefined)
+			} catch {}
+		}
+		sessions.delete(sessionId)
+	}
+	const get = sessionId => sessions.get(sessionId)?.sock
+	const list = () => [...sessions.keys()]
+
+	return { add, remove, get, list }
+}
+exports.createSessionPool = createSessionPool

package/lib/Utils/signal.js

@@ -0,0 +1,224 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.getNextPreKeysNode =
+	exports.getNextPreKeys =
+	exports.extractDeviceJids =
+	exports.parseAndInjectE2ESessions =
+	exports.extractE2ESessionFromRetryReceipt =
+	exports.xmppPreKey =
+	exports.xmppSignedPreKey =
+	exports.generateOrGetPreKeys =
+	exports.getPreKeys =
+	exports.createSignalIdentity =
+		void 0
+const Defaults_1 = require('../Defaults')
+const WABinary_1 = require('../WABinary')
+const crypto_1 = require('./crypto')
+const generics_1 = require('./generics')
+function chunk(array, size) {
+	const chunks = []
+	for (let i = 0; i < array.length; i += size) {
+		chunks.push(array.slice(i, i + size))
+	}
+	return chunks
+}
+const createSignalIdentity = (wid, accountSignatureKey) => {
+	return {
+		identifier: { name: wid, deviceId: 0 },
+		identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
+	}
+}
+exports.createSignalIdentity = createSignalIdentity
+const getPreKeys = async ({ get }, min, limit) => {
+	const idList = []
+	for (let id = min; id < limit; id++) {
+		idList.push(id.toString())
+	}
+	return get('pre-key', idList)
+}
+exports.getPreKeys = getPreKeys
+const generateOrGetPreKeys = (creds, range) => {
+	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] = crypto_1.Curve.generateKeyPair()
+		}
+	}
+	return {
+		newPreKeys,
+		lastPreKeyId,
+		preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+	}
+}
+exports.generateOrGetPreKeys = generateOrGetPreKeys
+const xmppSignedPreKey = key => ({
+	tag: 'skey',
+	attrs: {},
+	content: [
+		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
+		{ tag: 'value', attrs: {}, content: key.keyPair.public },
+		{ tag: 'signature', attrs: {}, content: key.signature }
+	]
+})
+exports.xmppSignedPreKey = xmppSignedPreKey
+const xmppPreKey = (pair, id) => ({
+	tag: 'key',
+	attrs: {},
+	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
+		}
+		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) {
+		for (const node of nodesChunk) {
+			const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey')
+			const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key')
+			const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity')
+			const jid = node.attrs.jid
+			const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4)
+			await repository.injectE2ESession({
+				jid,
+				session: {
+					registrationId: registrationId,
+					identityKey: (0, crypto_1.generateSignalPubKey)(identity),
+					signedPreKey: extractKey(signedKey),
+					preKey: extractKey(key)
+				}
+			})
+		}
+	}
+}
+exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions
+const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+	const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid)
+	const extracted = []
+	for (const userResult of result) {
+		const { devices, id } = userResult
+		const decoded = (0, WABinary_1.jidDecode)(id),
+			{ 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 === WABinary_1.WAJIDDomains.LID
+							? WABinary_1.WAJIDDomains.HOSTED_LID
+							: WABinary_1.WAJIDDomains.HOSTED
+				}
+				extracted.push({
+					user,
+					device,
+					domainType,
+					server: (0, WABinary_1.getServerFromDomainType)(server, domainType)
+				})
+			}
+		}
+	}
+	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 = {
+		nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+		firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
+	}
+	await keys.set({ 'pre-key': newPreKeys })
+	const preKeys = await (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
+	return { update, preKeys }
+}
+exports.getNextPreKeys = getNextPreKeys
+const getNextPreKeysNode = async (state, count) => {
+	const { creds } = state
+	const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count)
+	const node = {
+		tag: 'iq',
+		attrs: {
+			xmlns: 'encrypt',
+			type: 'set',
+			to: WABinary_1.S_WHATSAPP_NET
+		},
+		content: [
+			{ 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)
+		]
+	}
+	return { update, node }
+}
+exports.getNextPreKeysNode = getNextPreKeysNode

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,40 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.buildAckStanza = buildAckStanza
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+function buildAckStanza(node, errorCode, meId) {
+	const { tag, attrs } = node
+	const stanza = {
+		tag: 'ack',
+		attrs: {
+			id: attrs.id,
+			to: attrs.from,
+			class: tag
+		}
+	}
+	if (errorCode) {
+		stanza.attrs.error = errorCode.toString()
+	}
+	if (attrs.participant) {
+		stanza.attrs.participant = attrs.participant
+	}
+	if (attrs.recipient) {
+		stanza.attrs.recipient = attrs.recipient
+	}
+	// WA Web always includes type when present: `n.type || DROP_ATTR`
+	if (attrs.type) {
+		stanza.attrs.type = attrs.type
+	}
+	// WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+	if (tag === 'message' && meId) {
+		stanza.attrs.from = meId
+	}
+	return stanza
+}