@badzz88/baileys 8.5.4 → 8.5.5

package/lib/Utils/signal.js

@@ -4,6 +4,7 @@ exports.getNextPreKeysNode =
 	exports.getNextPreKeys =
 	exports.extractDeviceJids =
 	exports.parseAndInjectE2ESessions =
+	exports.extractE2ESessionFromRetryReceipt =
 	exports.xmppPreKey =
 	exports.xmppSignedPreKey =
 	exports.generateOrGetPreKeys =
@@ -53,11 +54,9 @@ const generateOrGetPreKeys = (creds, range) => {
 	}
 }
 exports.generateOrGetPreKeys = generateOrGetPreKeys
-
-
-const xmppSignedPreKey = (key, cipherSuite) => ({
+const xmppSignedPreKey = key => ({
 	tag: 'skey',
-	attrs: cipherSuite !== undefined ? { key_cipher_suite: cipherSuite } : {},
+	attrs: {},
 	content: [
 		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
 		{ tag: 'value', attrs: {}, content: key.keyPair.public },
@@ -65,36 +64,72 @@ const xmppSignedPreKey = (key, cipherSuite) => ({
 	]
 })
 exports.xmppSignedPreKey = xmppSignedPreKey
-const xmppPreKey = (pair, id, cipherSuite) => ({
+const xmppPreKey = (pair, id) => ({
 	tag: 'key',
-	attrs: cipherSuite !== undefined ? { key_cipher_suite: cipherSuite } : {},
+	attrs: {},
 	content: [
 		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
 		{ tag: 'value', attrs: {}, content: pair.public }
 	]
 })
 exports.xmppPreKey = xmppPreKey
-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 } : {})
+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) {
@@ -129,9 +164,9 @@ const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
 		if (!Array.isArray(deviceList)) continue
 		for (const { id: device, keyIndex, isHosted } of deviceList) {
 			if (
-				(!excludeZeroDevices || device !== 0) && 
-				((myUser !== user && myLid !== user) || myDevice !== device) && 
-				(device === 0 || !!keyIndex) 
+				(!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 =
@@ -151,7 +186,10 @@ 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 = {
@@ -177,9 +215,6 @@ 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)
 		]

package/lib/Utils/stanza-ack.js

@@ -1,50 +1,24 @@
 'use strict'
 Object.defineProperty(exports, '__esModule', { value: true })
 exports.buildAckStanza = buildAckStanza
-
-
-const CALL_STANZA_TAGS = new Set([
-	'offer',
-	'offer_notice',
-	'terminate',
-	'accept',
-	'reject',
-	'preaccept',
-	'transport',
-	'video',
-	'duration',
-	'mute_v2',
-	'lobby',
-	'heartbeat',
-	'relaylatency',
-	'link_query',
-	'group_update',
-	'accept_ack',
-	'enc-rekey',
-	'enc_rekey',
-	'peer_state',
-	'group_info',
-	'video_state',
-	'video_state_ack',
-	'flow_control',
-	'waiting_room_request'
-])
-
+/**
+ * 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 isCallStanza = CALL_STANZA_TAGS.has(tag)
 	const stanza = {
 		tag: 'ack',
 		attrs: {
 			id: attrs.id,
 			to: attrs.from,
-			class: isCallStanza ? 'call' : tag
+			class: tag
 		}
 	}
-	
-	if (isCallStanza) {
-		stanza.attrs.type = tag
-	}
 	if (errorCode) {
 		stanza.attrs.error = errorCode.toString()
 	}
@@ -54,12 +28,11 @@ function buildAckStanza(node, errorCode, meId) {
 	if (attrs.recipient) {
 		stanza.attrs.recipient = attrs.recipient
 	}
-	
-	
-	if (attrs.type && !isCallStanza) {
+	// 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
 	}

package/lib/Utils/sticker.d.ts

@@ -0,0 +1,17 @@
+export interface StickerMetaOptions {
+	packName?: string
+	packPublisher?: string
+	categories?: string[]
+}
+
+export function addExifToWebp(webpBuffer: Buffer, options?: StickerMetaOptions): Promise<Buffer>
+
+export function imageToWebpSticker(
+	imageBuffer: Buffer,
+	options?: StickerMetaOptions & { quality?: number }
+): Promise<Buffer>
+
+export function videoToWebpSticker(
+	videoBuffer: Buffer,
+	options?: StickerMetaOptions & { fps?: number; seconds?: number }
+): Promise<Buffer>

package/lib/Utils/sticker.js

@@ -0,0 +1,145 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.imageToWebpSticker = exports.videoToWebpSticker = exports.addExifToWebp = void 0
+const os = require('os')
+const path = require('path')
+const fs = require('fs')
+const crypto = require('crypto')
+const { exec } = require('child_process')
+
+/**
+ * Builds and writes the EXIF metadata WhatsApp expects on sticker webp files
+ * (pack name / author, shown when a user long-presses a sticker).
+ * Converts the file to the "extended" (VP8X) WebP container if it isn't already,
+ * since that's the container format that actually carries an EXIF chunk.
+ * Returns the new buffer with EXIF attached.
+ */
+const addExifToWebp = async (webpBuffer, { packName = '', packPublisher = '', categories = [] } = {}) => {
+	const json = {
+		'sticker-pack-id': crypto.randomBytes(16).toString('hex'),
+		'sticker-pack-name': packName,
+		'sticker-pack-publisher': packPublisher,
+		emojis: categories.length ? categories : ['😀']
+	}
+	const jsonBuffer = Buffer.from(JSON.stringify(json), 'utf-8')
+	// TIFF header + IFD entry pointing at a single custom tag (0x5741 "AW") holding
+	// the JSON payload -- this is the exact structure WhatsApp's client parses.
+	const exifAttr = Buffer.from([
+		0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
+		0x00, 0x00, 0x00
+	])
+	exifAttr.writeUIntLE(jsonBuffer.length, 14, 4)
+	const exifPayload = Buffer.concat([exifAttr, jsonBuffer])
+	const pad = buf => (buf.length % 2 === 1 ? Buffer.concat([buf, Buffer.from([0x00])]) : buf)
+	const makeChunk = (tag, data) => {
+		const sizeField = Buffer.alloc(4)
+		sizeField.writeUInt32LE(data.length, 0)
+		return Buffer.concat([Buffer.from(tag, 'ascii'), sizeField, pad(data)])
+	}
+	const exifChunk = makeChunk('EXIF', exifPayload)
+	if (webpBuffer.slice(0, 4).toString('ascii') !== 'RIFF' || webpBuffer.slice(8, 12).toString('ascii') !== 'WEBP') {
+		throw new Error('addExifToWebp expects a valid WebP buffer')
+	}
+	let offset = 12
+	let vp8xChunk = null
+	let vp8xOffset = -1
+	const otherChunks = []
+	while (offset < webpBuffer.length) {
+		const tag = webpBuffer.slice(offset, offset + 4).toString('ascii')
+		const size = webpBuffer.readUInt32LE(offset + 4)
+		const dataStart = offset + 8
+		const dataEnd = dataStart + size
+		const chunkTotal = 8 + size + (size % 2)
+		if (tag === 'VP8X') {
+			vp8xChunk = webpBuffer.slice(offset, offset + chunkTotal)
+			vp8xOffset = offset
+		} else if (tag !== 'EXIF') {
+			// drop any pre-existing EXIF chunk, keep everything else (VP8/VP8L/ANIM/ANMF/ICCP/...)
+			otherChunks.push(webpBuffer.slice(offset, offset + chunkTotal))
+		}
+		offset += chunkTotal
+	}
+	let flags
+	let canvasWidth
+	let canvasHeight
+	if (vp8xChunk) {
+		flags = vp8xChunk.readUInt8(8)
+		canvasWidth = vp8xChunk.readUIntLE(12, 3) + 1
+		canvasHeight = vp8xChunk.readUIntLE(15, 3) + 1
+	} else {
+		flags = 0
+		let sharp
+		try {
+			sharp = require('sharp')
+		} catch (error) {
+			throw new Error('addExifToWebp needs the optional "sharp" dependency to read image dimensions')
+		}
+		const meta = await sharp(webpBuffer).metadata()
+		canvasWidth = meta.width
+		canvasHeight = meta.height
+	}
+	flags |= 0x08 // set the "has EXIF metadata" bit
+	const vp8xData = Buffer.alloc(10)
+	vp8xData.writeUInt8(flags, 0)
+	vp8xData.writeUIntLE(canvasWidth - 1, 4, 3)
+	vp8xData.writeUIntLE(canvasHeight - 1, 7, 3)
+	const newVp8xChunk = makeChunk('VP8X', vp8xData)
+	const body = Buffer.concat([newVp8xChunk, ...otherChunks, exifChunk])
+	const fileSize = Buffer.alloc(4)
+	fileSize.writeUInt32LE(4 + body.length, 0) // 4 = 'WEBP'
+	return Buffer.concat([Buffer.from('RIFF', 'ascii'), fileSize, Buffer.from('WEBP', 'ascii'), body])
+}
+exports.addExifToWebp = addExifToWebp
+
+/**
+ * Converts a static image buffer to a WhatsApp sticker-ready webp buffer using `sharp`.
+ * @param {Buffer} imageBuffer
+ * @param {{ packName?: string, packPublisher?: string, categories?: string[], quality?: number }} [options]
+ * @returns {Promise<Buffer>}
+ */
+const imageToWebpSticker = async (imageBuffer, options = {}) => {
+	let sharp
+	try {
+		sharp = require('sharp')
+	} catch (error) {
+		throw new Error('imageToWebpSticker requires the optional "sharp" dependency to be installed')
+	}
+	const webp = await sharp(imageBuffer)
+		.resize(512, 512, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+		.webp({ quality: options.quality ?? 80 })
+		.toBuffer()
+	return addExifToWebp(webp, options)
+}
+exports.imageToWebpSticker = imageToWebpSticker
+
+/**
+ * Converts a video buffer to an animated WhatsApp sticker-ready webp buffer.
+ * Requires the `ffmpeg` binary to be available on PATH.
+ * @param {Buffer} videoBuffer
+ * @param {{ packName?: string, packPublisher?: string, categories?: string[], fps?: number, seconds?: number }} [options]
+ * @returns {Promise<Buffer>}
+ */
+const videoToWebpSticker = async (videoBuffer, options = {}) => {
+	const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'xazbails-sticker-'))
+	const inputPath = path.join(tmpDir, 'input.mp4')
+	const outputPath = path.join(tmpDir, 'output.webp')
+	fs.writeFileSync(inputPath, videoBuffer)
+	const fps = options.fps ?? 10
+	const seconds = options.seconds ?? 5
+	const cmd =
+		`ffmpeg -y -i ${inputPath} -t ${seconds} -vf ` +
+		`"fps=${fps},scale=512:512:force_original_aspect_ratio=decrease,` +
+		`pad=512:512:(ow-iw)/2:(oh-ih)/2:color=0x00000000,split[a][b];` +
+		`[a]palettegen=reserve_transparent=1[p];[b][p]paletteuse" ` +
+		`-loop 0 -preset default -an -vsync 0 ${outputPath}`
+	try {
+		await new Promise((resolve, reject) => {
+			exec(cmd, err => (err ? reject(err) : resolve()))
+		})
+		const webp = fs.readFileSync(outputPath)
+		return await addExifToWebp(webp, options)
+	} finally {
+		fs.rmSync(tmpDir, { recursive: true, force: true })
+	}
+}
+exports.videoToWebpSticker = videoToWebpSticker

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

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, '__esModule', { value: true })
 exports.emitSyncActionResults = exports.processContactAction = void 0
 const WABinary_1 = require('../WABinary')
-
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
 const processContactAction = (action, id, logger) => {
 	const results = []
 	if (!id) {
@@ -14,9 +17,9 @@ const processContactAction = (action, id, logger) => {
 	}
 	const lidJid = action.lidJid
 	const idIsPn = (0, WABinary_1.isPnUser)(id)
-	
+	// PN is in index[1], not in contactAction.pnJid which is usually null
 	const phoneNumber = idIsPn ? id : action.pnJid || undefined
-	
+	// Always emit contacts.upsert
 	results.push({
 		event: 'contacts.upsert',
 		data: [
@@ -29,7 +32,7 @@ const processContactAction = (action, id, logger) => {
 			}
 		]
 	})
-	
+	// Emit lid-mapping.update if we have valid LID-PN pair
 	if (lidJid && (0, WABinary_1.isLidUser)(lidJid) && idIsPn) {
 		results.push({
 			event: 'lid-mapping.update',

package/lib/Utils/tc-token-utils.js

@@ -10,16 +10,21 @@ exports.resolveIssuanceJid = resolveIssuanceJid
 exports.buildTcTokenFromJid = buildTcTokenFromJid
 exports.storeTcTokensFromIqResult = storeTcTokensFromIqResult
 const WABinary_1 = require('../WABinary')
-
-
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
 const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/
-
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
 function isRegularUser(jid) {
 	if (!jid) return false
 	const user = jid.split('@')[0] ?? ''
-	if (user === '0') return false 
-	if (BOT_PHONE_REGEX.test(user)) return false 
-	if ((0, WABinary_1.isJidMetaAI)(jid)) return false 
+	if (user === '0') return false // PSA
+	if (BOT_PHONE_REGEX.test(user)) return false // Bot by phone pattern
+	if ((0, WABinary_1.isJidMetaAI)(jid)) return false // MetaAI (@bot server)
 	return !!(
 		(0, WABinary_1.isPnUser)(jid) ||
 		(0, WABinary_1.isLidUser)(jid) ||
@@ -28,11 +33,11 @@ function isRegularUser(jid) {
 		jid.endsWith('@c.us')
 	)
 }
-const TC_TOKEN_BUCKET_DURATION = 604800 
-const TC_TOKEN_NUM_BUCKETS = 4 
-
+const TC_TOKEN_BUCKET_DURATION = 604800 // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4 // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
 exports.TC_TOKEN_INDEX_KEY = '__index'
-
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
 async function readTcTokenIndex(keys) {
 	const data = await keys.get('tctoken', [exports.TC_TOKEN_INDEX_KEY])
 	const entry = data[exports.TC_TOKEN_INDEX_KEY]
@@ -45,7 +50,7 @@ async function readTcTokenIndex(keys) {
 		return []
 	}
 }
-
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
 async function buildMergedTcTokenIndexWrite(keys, addedJids) {
 	const persisted = await readTcTokenIndex(keys)
 	const merged = new Set(persisted)
@@ -56,10 +61,10 @@ async function buildMergedTcTokenIndexWrite(keys, addedJids) {
 		[exports.TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
 	}
 }
-
+// WA Web has separate sender/receiver AB props for these but they're identical today
 function isTcTokenExpired(timestamp) {
 	if (timestamp === null || timestamp === undefined) return true
-	const ts = typeof timestamp === 'string' ? parseInt(timestamp, 10) : timestamp
+	const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp
 	if (isNaN(ts)) return true
 	const now = Math.floor(Date.now() / 1000)
 	const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)
@@ -74,13 +79,13 @@ function shouldSendNewTcToken(senderTimestamp) {
 	const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION)
 	return currentBucket > senderBucket
 }
-
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
 async function resolveTcTokenJid(jid, getLIDForPN) {
 	if ((0, WABinary_1.isLidUser)(jid)) return jid
 	const lid = await getLIDForPN(jid)
 	return lid ?? jid
 }
-
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
 async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
 	if (issueToLid) {
 		if ((0, WABinary_1.isLidUser)(jid)) return jid
@@ -102,9 +107,9 @@ async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDFor
 		const tcTokenBuffer = entry?.token
 		if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
 			if (tcTokenBuffer) {
-				
-				
-				
+				// Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+				// after we drop the unusable peer token. Only wipe the record entirely when
+				// there's nothing worth keeping.
 				const cleared =
 					entry?.senderTimestamp !== undefined
 						? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
@@ -131,7 +136,7 @@ async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForP
 		if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
 			continue
 		}
-		
+		// In notifications tokenNode.attrs.jid is your own device JID, not the sender's
 		const rawJid = (0, WABinary_1.jidNormalizedUser)(fallbackJid || tokenNode.attrs.jid)
 		if (!isRegularUser(rawJid)) continue
 		const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN)
@@ -139,7 +144,7 @@ async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForP
 		const existingEntry = existingTcData[storageJid]
 		const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0
 		const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0
-		
+		// timestamp-less tokens would be immediately expired
 		if (!incomingTs) continue
 		if (existingTs > 0 && existingTs > incomingTs) continue
 		await keys.set({

package/lib/Utils/use-multi-file-auth-state.js

@@ -7,12 +7,12 @@ const path_1 = require('path')
 const index_js_1 = require('../../WAProto/index.js')
 const auth_utils_1 = require('./auth-utils')
 const generics_1 = require('./generics')
-
-
-
-
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
 const fileLocks = new Map()
-
+// Get or create a mutex for a specific file path
 const getFileLock = path => {
 	let mutex = fileLocks.get(path)
 	if (!mutex) {
@@ -21,37 +21,21 @@ const getFileLock = path => {
 	}
 	return mutex
 }
-
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
 const useMultiFileAuthState = async folder => {
-	
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	const writeData = async (data, file) => {
 		const filePath = (0, path_1.join)(folder, fixFileName(file))
 		const mutex = getFileLock(filePath)
 		return mutex.acquire().then(async release => {
-			const tmpPath = `${filePath}.tmp`
-			
-			
-			
-			
-			
-			const existingStat = await (0, promises_1.stat)(filePath).catch(() => undefined)
 			try {
-				await (0, promises_1.writeFile)(
-					tmpPath,
-					JSON.stringify(data, generics_1.BufferJSON.replacer),
-					existingStat ? { mode: existingStat.mode & 0o777 } : undefined
-				)
-				try {
-					await (0, promises_1.rename)(tmpPath, filePath)
-				} catch {
-					
-					
-					await (0, promises_1.writeFile)(
-						filePath,
-						JSON.stringify(data, generics_1.BufferJSON.replacer),
-						existingStat ? { mode: existingStat.mode & 0o777 } : undefined
-					)
-				}
+				await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer))
 			} finally {
 				release()
 			}