fix: add try/catch to delayed PreKey deletion to prevent unhandled rejection

The setTimeout async callback in removePreKey could cause unhandled promise
rejection if the keystore was destroyed (connection closed) before the
5-min grace period expired.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/Signal/libsignal.ts

@@ -302,6 +302,25 @@ export function makeLibSignalRepository(
 	// Promise instead of each spawning their own DB transactions.
 	const migrationInFlight = new Map<string, Promise<{ migrated: number; skipped: number; total: number }>>()
 
+	// Resolve PN JID to its canonical LID JID for transaction locking.
+	// This prevents PN/LID race conditions where concurrent operations for the
+	// same logical contact acquire different mutex locks because one uses PN
+	// and the other uses LID. (Aligned with WABA behavior — all operations use LID internally.)
+	const resolveCanonicalJid = async(jid: string): Promise<string> => {
+		if (isAnyLidUser(jid)) {
+			return jid
+		}
+
+		if (isAnyPnUser(jid)) {
+			const lid = await lidMapping.getLIDForPN(jid)
+			if (lid) {
+				return lid
+			}
+		}
+
+		return jid
+	}
+
 	const repository: SignalRepositoryWithLIDStore = {
 		decryptGroupMessage({ group, authorJid, msg }) {
 			const senderName = jidToSignalSenderKeyName(group, authorJid)
@@ -396,23 +415,24 @@ export function makeLibSignalRepository(
 				return result
 			}
 
-			// If it's not a sync message, we need to ensure atomicity
-			// For regular messages, we use a transaction to ensure atomicity
+			// Use canonical JID (PN→LID resolved) as transaction key to prevent
+			// PN/LID race conditions on the same logical session.
+			const canonicalJid = await resolveCanonicalJid(jid)
 			return parsedKeys.transaction(async () => {
 				return await doDecrypt()
-			}, jid)
+			}, canonicalJid)
 		},
 
 		async encryptMessage({ jid, data }) {
 			const addr = jidToSignalProtocolAddress(jid)
 			const cipher = new libsignal.SessionCipher(storage, addr)
 
-			// Use transaction to ensure atomicity
+			const canonicalJid = await resolveCanonicalJid(jid)
 			return parsedKeys.transaction(async () => {
 				const { type: sigType, body } = await cipher.encrypt(data)
 				const type = sigType === 3 ? 'pkmsg' : 'msg'
 				return { type, ciphertext: Buffer.from(body, 'binary') }
-			}, jid)
+			}, canonicalJid)
 		},
 
 		async encryptGroupMessage({ group, meId, data }) {
@@ -654,9 +674,10 @@ export function makeLibSignalRepository(
 								// Session exists (guaranteed from device discovery)
 								const fromSession = libsignal.SessionRecord.deserialize(pnSession)
 								if (fromSession.haveOpenSession()) {
-									// Queue for bulk update: copy to LID, delete from PN
+									// Queue for bulk update: copy to LID, retain PN session.
+									// WABA retains both PN and LID sessions during migration to avoid
+									// No Session errors if messages arrive via PN before migration completes.
 									sessionUpdates[lidAddrStr] = fromSession.serialize()
-									sessionUpdates[pnAddrStr] = null
 
 									migratedCount++
 								}
@@ -776,6 +797,13 @@ function signalStorage(
 		return id
 	}
 
+	// Delayed PreKey deletion: grace period to handle race conditions
+	// where two pkmsg with the same preKeyId arrive nearly simultaneously.
+	// WABA deletes immediately (33ms), but we add a 5-min grace period
+	// because we can't handle "Invalid PreKey ID" errors at the native level.
+	const PREKEY_GRACE_PERIOD_MS = 5 * 60 * 1000 // 5 minutes
+	const pendingPreKeyDeletions = new Map<string, ReturnType<typeof setTimeout>>()
+
 	return {
 		loadSession: async (id: string) => {
 			try {
@@ -808,7 +836,26 @@ function signalStorage(
 				}
 			}
 		},
-		removePreKey: (id: number) => keys.set({ 'pre-key': { [id]: null } }),
+		removePreKey: (id: number) => {
+			const keyId = id.toString()
+			// Clear any existing timer for this key
+			const existing = pendingPreKeyDeletions.get(keyId)
+			if (existing) {
+				clearTimeout(existing)
+			}
+
+			// Schedule deletion after grace period
+			const timer = setTimeout(async () => {
+				pendingPreKeyDeletions.delete(keyId)
+				try {
+					await keys.set({ 'pre-key': { [id]: null } })
+				} catch {
+					// Keystore may be destroyed if connection closed — safe to ignore
+				}
+			}, PREKEY_GRACE_PERIOD_MS)
+
+			pendingPreKeyDeletions.set(keyId, timer)
+		},
 		loadSignedPreKey: () => {
 			const key = creds.signedPreKey
 			return {
@@ -898,14 +945,24 @@ function signalStorage(
 					// IDENTITY KEY CHANGED - contact reinstalled WhatsApp or switched devices
 					const previousFingerprint = generateKeyFingerprint(existingKey)
 
-					// Delete old session and save new identity key atomically
+					// Delete old session and save new identity key atomically.
+					// Store identity in BOTH LID and PN addresses (WABA stores in both
+					// recipient_account_type=0 and type=1 with CONFLICT_REPLACE).
+					const identityUpdates: Record<string, Uint8Array> = { [wireJid]: identityKey }
+					if (wireJid !== id) {
+						identityUpdates[id] = identityKey
+					}
+
 					await keys.set({
 						session: { [wireJid]: null },
-						'identity-key': { [wireJid]: identityKey }
+						'identity-key': identityUpdates
 					})
 
-					// Update cache
+					// Update cache for both addresses
 					identityKeyCache.set(wireJid, identityKey)
+					if (wireJid !== id) {
+						identityKeyCache.set(id, identityKey)
+					}
 
 					// Record metrics
 					metrics.signalIdentityChanges?.inc({ type: 'changed' })
@@ -941,10 +998,19 @@ function signalStorage(
 
 				if (!existingKey) {
 					// NEW CONTACT - Trust On First Use (TOFU)
-					await keys.set({ 'identity-key': { [wireJid]: identityKey } })
+					// Store in both LID and PN addresses (aligned with WABA dual identity storage)
+					const identityUpdates: Record<string, Uint8Array> = { [wireJid]: identityKey }
+					if (wireJid !== id) {
+						identityUpdates[id] = identityKey
+					}
 
-					// Update cache
+					await keys.set({ 'identity-key': identityUpdates })
+
+					// Update cache for both addresses
 					identityKeyCache.set(wireJid, identityKey)
+					if (wireJid !== id) {
+						identityKeyCache.set(id, identityKey)
+					}
 
 					// Record metrics
 					metrics.signalIdentityChanges?.inc({ type: 'new' })

src/Socket/messages-recv.ts

@@ -1314,7 +1314,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		let shouldRecreateSession = false
 		let recreateReason = ''
 
-		if (enableAutoSessionRecreation && messageRetryManager && retryCount > 1) {
+		if (enableAutoSessionRecreation && messageRetryManager && retryCount >= 1) {
 			try {
 				// Check if we have a session with this JID
 				const sessionId = signalRepository.jidToSignalProtocolAddress(fromJid)
@@ -2033,7 +2033,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		let shouldRecreateSession = false
 		let recreateReason = ''
 
-		if (enableAutoSessionRecreation && messageRetryManager && retryCount > 1) {
+		if (enableAutoSessionRecreation && messageRetryManager && retryCount >= 1) {
 			try {
 				const sessionId = signalRepository.jidToSignalProtocolAddress(participant)
 

src/Types/Message.ts

@@ -54,14 +54,12 @@ export type WAMediaUpload = Buffer | WAMediaPayloadStream | WAMediaPayloadURL
  * Individual sticker in a sticker pack
  */
 export type Sticker = {
-	/** Buffer, Stream or URL of the sticker image (WebP or Lottie/WAS format) */
+	/** Buffer, Stream or URL of the sticker image (will be converted to WebP if needed) */
 	data: WAMediaUpload
 	/** Array of emojis associated with this sticker (max 3 recommended per WhatsApp standards) */
 	emojis?: string[]
 	/** Accessibility label for screen readers (max 125 chars for static, 255 for animated) */
 	accessibilityLabel?: string
-	/** Force Lottie format detection (auto-detected if omitted) */
-	isLottie?: boolean
 }
 
 /**

src/Utils/decode-wa-message.ts

@@ -14,7 +14,6 @@ import {
 	isJidStatusBroadcast,
 	isLidUser,
 	isPnUser,
-	jidDecode
 	//	transferDevice
 } from '../WABinary'
 import { unpadRandomMax16 } from './generics'
@@ -488,8 +487,9 @@ export function isCorruptedSessionError(error: any): boolean {
 }
 
 /**
- * Clean up corrupted session by deleting all device sessions for a JID.
- * Signal Protocol will automatically recreate the session on next message.
+ * Clean up corrupted session for a specific device JID.
+ * WABA behavior: DELETE sessions WHERE recipient_id=? AND device_id=?
+ * Only deletes the exact device that was corrupted, not all devices.
  *
  * NOTE: This should NOT be called on every Bad MAC error (hot path).
  * Instead, let the retry+pkmsg flow handle recovery naturally (like WhatsApp does).
@@ -500,45 +500,7 @@ export async function cleanupCorruptedSession(
 	repository: SignalRepositoryWithLIDStore,
 	logger: ILogger
 ): Promise<number> {
-	const { user, device } = jidDecode(jid) || {}
-	if (!user) {
-		logger.warn({ jid }, 'Cannot cleanup session - invalid JID')
-		return 0
-	}
-
-	// Build list of JIDs to delete (primary + secondary devices)
-	const jidsToDelete: string[] = []
-
-	// Determine domain type correctly (handle hosted JIDs)
-	// JID formats:
-	//   - PN: user@s.whatsapp.net
-	//   - LID: user@lid
-	//   - Hosted PN: user@hosted
-	//   - Hosted LID: user@hosted.lid
-	const isLID = jid.endsWith('@lid') || jid.endsWith('@hosted.lid')
-	const isHosted = jid.includes('@hosted')
-
-	let domain: string
-	if (isLID) {
-		domain = isHosted ? 'hosted.lid' : 'lid'
-	} else {
-		domain = isHosted ? 'hosted' : 's.whatsapp.net'
-	}
-
-	// Primary device (0)
-	jidsToDelete.push(`${user}@${domain}`)
-
-	// Secondary devices (1-5 common range for Web/Desktop/etc)
-	for (let i = 1; i <= 5; i++) {
-		jidsToDelete.push(`${user}:${i}@${domain}`)
-	}
-
-	// If specific device was identified and > 5, ensure it's included
-	if (device !== undefined && device > 5) {
-		jidsToDelete.push(`${user}:${device}@${domain}`)
-	}
-
-	await repository.deleteSession(jidsToDelete)
-
-	return jidsToDelete.length
+	await repository.deleteSession([jid])
+	logger.info({ jid }, 'Cleaned up corrupted session for specific device')
+	return 1
 }

src/Utils/message-retry-manager.ts

@@ -218,7 +218,7 @@ export class MessageRetryManager {
 		if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
 			const now = Date.now()
 			const prevTime = this.sessionRecreateHistory.get(jid)
-			const MAC_ERROR_COOLDOWN_MS = 10_000 // 10 seconds
+			const MAC_ERROR_COOLDOWN_MS = 1_000 // 1 second — WABA recovers faster
 
 			if (prevTime && now - prevTime < MAC_ERROR_COOLDOWN_MS) {
 				const reasonName = RetryReason[errorCode] || `code_${errorCode}`

src/Utils/sticker-pack.ts

@@ -2,7 +2,6 @@ import { Boom } from '@hapi/boom'
 import { createHash } from 'crypto'
 import { zipSync } from 'fflate'
 import { promises as fs } from 'fs'
-import { gzipSync, gunzipSync } from 'zlib'
 import { proto } from '../../WAProto/index.js'
 import type { MediaType } from '../Defaults/index.js'
 import type { StickerPack, WAMediaUpload, WAMediaUploadFunction } from '../Types/Message.js'
@@ -102,49 +101,6 @@ export const isAnimatedWebP = (buffer: Buffer): boolean => {
 	return false
 }
 
-/**
- * Detecta se um buffer é Lottie JSON (raw ou gzip-compressed/WAS)
- *
- * WABA usa mimetype `application/was` para stickers Lottie.
- * WAS (WhatsApp Animated Sticker) = gzip-compressed Lottie JSON.
- *
- * Detecção:
- * - Gzip (0x1f 0x8b): descomprime e verifica se é Lottie JSON
- * - JSON bruto: verifica campos Lottie obrigatórios (v, ip, op, layers)
- *
- * @param buffer - Buffer to check
- * @returns true if buffer is Lottie/WAS format
- */
-export const isLottieBuffer = (buffer: Buffer): boolean => {
-	if (buffer.length < 2) return false
-
-	let jsonBuffer: Buffer
-
-	// Check if gzip-compressed (WAS format)
-	if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
-		try {
-			// SECURITY: Limit decompressed output to 50MB to prevent decompression bombs
-			jsonBuffer = gunzipSync(buffer, { maxOutputLength: 50 * 1024 * 1024 }) as Buffer
-		} catch {
-			return false
-		}
-	} else if (buffer[0] === 0x7b) {
-		// Starts with '{' - could be raw Lottie JSON
-		jsonBuffer = buffer
-	} else {
-		return false
-	}
-
-	// Validate Lottie JSON structure: must have v, ip, op, AND layers
-	try {
-		const str = jsonBuffer.toString('utf8', 0, Math.min(jsonBuffer.length, 4096))
-		// Quick check for ALL required Lottie fields
-		return str.includes('"v"') && str.includes('"layers"') && str.includes('"ip"') && str.includes('"op"')
-	} catch {
-		return false
-	}
-}
-
 /**
  * Converte uma imagem para WebP usando Sharp
  * Preserva o buffer original se já for WebP para manter EXIF e animações
@@ -158,25 +114,12 @@ export const isLottieBuffer = (buffer: Buffer): boolean => {
 const convertToWebP = async (
 	buffer: Buffer,
 	logger?: ILogger
-): Promise<{ webpBuffer: Buffer; isAnimated: boolean; isLottie: boolean }> => {
-	// Lottie/WAS: ensure gzip-compressed format (WAS = gzip Lottie JSON)
-	if (isLottieBuffer(buffer)) {
-		let wasBuffer = buffer
-		// Raw Lottie JSON (starts with '{') must be gzipped to produce valid WAS
-		if (buffer[0] === 0x7b) {
-			logger?.trace('Raw Lottie JSON detected, gzip-compressing to WAS format')
-			wasBuffer = gzipSync(buffer) as Buffer
-		}
-
-		logger?.trace('Input is Lottie/WAS format')
-		return { webpBuffer: wasBuffer, isAnimated: true, isLottie: true }
-	}
-
+): Promise<{ webpBuffer: Buffer; isAnimated: boolean }> => {
 	// Se já é WebP, preserva o buffer original (mantém EXIF e animações)
 	if (isWebPBuffer(buffer)) {
 		const isAnimated = isAnimatedWebP(buffer)
 		logger?.trace({ isAnimated }, 'Input is already WebP, preserving original buffer')
-		return { webpBuffer: buffer, isAnimated, isLottie: false }
+		return { webpBuffer: buffer, isAnimated }
 	}
 
 	// Tenta usar Sharp para converter
@@ -192,7 +135,7 @@ const convertToWebP = async (
 	logger?.trace('Converting image to WebP using Sharp')
 	const webpBuffer = await lib.sharp.default(buffer).webp().toBuffer()
 
-	return { webpBuffer, isAnimated: false, isLottie: false }
+	return { webpBuffer, isAnimated: false }
 }
 
 /**
@@ -395,11 +338,9 @@ export type PrepareStickerPackMessageOptions = {
  *
  * **Especificações WhatsApp:**
  * - 3-30 stickers por pack (oficial)
- * - WebP ou Lottie/WAS (application/was)
- * - Stickers: 512x512 pixels (auto-resize)
+ * - WebP obrigatório
  * - Recomendado: 100KB por sticker estático, 500KB animado
- * - Tray icon: 96x96 pixels (PNG no ZIP)
- * - Thumbnail: 252x252 pixels (JPEG, upload separado)
+ * - Tray icon: 252x252 pixels
  *
  * @param stickerPack - Sticker pack data with stickers, cover, name, publisher
  * @param options - Upload function and optional logger
@@ -523,36 +464,9 @@ export const prepareStickerPackMessage = async (
 				// Obtém buffer do sticker
 				const buffer = await mediaToBuffer(sticker.data, `sticker ${i + 1}`)
 
-				// Detecta formato e converte se necessário
+				// Converte para WebP
 				// eslint-disable-next-line prefer-const
-				let { webpBuffer, isAnimated, isLottie } = await convertToWebP(buffer, logger)
-
-				// Validate explicit isLottie flag — must match detected format
-				if (sticker.isLottie !== undefined && sticker.isLottie !== isLottie) {
-					throw new Boom(
-						`Sticker ${i + 1}: explicit isLottie=${sticker.isLottie} does not match detected format (detected=${isLottie})`,
-						{ statusCode: 400 }
-					)
-				}
-
-				// WABA: Enforce 512x512 dimensions for WebP stickers (Lottie is vector, skip)
-				if (!isLottie && isWebPBuffer(webpBuffer)) {
-					const lib = await getImageProcessingLibrary()
-					if (lib?.sharp) {
-						const metadata = await lib.sharp.default(webpBuffer).metadata()
-						if (metadata.width !== 512 || metadata.height !== 512) {
-							logger?.trace(
-								{ index: i, width: metadata.width, height: metadata.height },
-								'Resizing sticker to 512x512 (WABA standard)'
-							)
-							webpBuffer = await lib.sharp
-								.default(webpBuffer)
-								.resize(512, 512, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
-								.webp()
-								.toBuffer()
-						}
-					}
-				}
+				let { webpBuffer, isAnimated } = await convertToWebP(buffer, logger)
 
 				// ENHANCEMENT: Auto-compression if exceeds 1MB (try quality 70, then 50)
 				const MAX_STICKER_SIZE = 1024 * 1024 // 1MB
@@ -569,7 +483,7 @@ export const prepareStickerPackMessage = async (
 					if (lib?.sharp) {
 						// Try quality 70
 						try {
-							const compressed70 = await lib.sharp.default(webpBuffer).webp({ quality: 70 }).toBuffer()
+							const compressed70 = await lib.sharp.default(buffer).webp({ quality: 70 }).toBuffer()
 
 							// eslint-disable-next-line max-depth
 							if (compressed70.length <= MAX_STICKER_SIZE) {
@@ -584,7 +498,7 @@ export const prepareStickerPackMessage = async (
 								)
 							} else {
 								// Try quality 50
-								const compressed50 = await lib.sharp.default(webpBuffer).webp({ quality: 50 }).toBuffer()
+								const compressed50 = await lib.sharp.default(buffer).webp({ quality: 50 }).toBuffer()
 
 								// eslint-disable-next-line max-depth
 								if (compressed50.length <= MAX_STICKER_SIZE) {
@@ -633,13 +547,12 @@ export const prepareStickerPackMessage = async (
 					)
 				}
 
-				// Gera nome do arquivo: hash.webp ou hash.was (WABA: plain_file_hash.ext)
+				// Gera nome do arquivo: hash.webp (deduplicação automática)
 				const sha256Hash = generateSha256Hash(webpBuffer)
-				const extension = isLottie ? 'was' : 'webp'
-				const fileName = `${sha256Hash}.${extension}`
+				const fileName = `${sha256Hash}.webp`
 
 				logger?.trace(
-					{ index: i, fileName, sizeKB: finalSizeKB.toFixed(2), isAnimated, isLottie },
+					{ index: i, fileName, sizeKB: finalSizeKB.toFixed(2), isAnimated },
 					'Sticker processed successfully'
 				)
 
@@ -647,7 +560,6 @@ export const prepareStickerPackMessage = async (
 					fileName,
 					webpBuffer,
 					isAnimated,
-					isLottie,
 					emojis: sticker.emojis || [],
 					accessibilityLabel: sticker.accessibilityLabel
 				}
@@ -666,7 +578,7 @@ export const prepareStickerPackMessage = async (
 	for (const result of processedStickers) {
 		if (!result) continue
 
-		const { fileName, webpBuffer, isAnimated, isLottie, emojis, accessibilityLabel } = result
+		const { fileName, webpBuffer, isAnimated, emojis, accessibilityLabel } = result
 
 		// SECURITY FIX #7: Check if this hash already exists (duplicate sticker)
 		const existingMetadata = metadataByHash.get(fileName)
@@ -693,14 +605,13 @@ export const prepareStickerPackMessage = async (
 			// New sticker - add to ZIP and create metadata
 			stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 as 0 }]
 
-			// WABA: mimetype é 'application/was' para Lottie, 'image/webp' para WebP
 			const metadata: proto.Message.StickerPackMessage.ISticker = {
 				fileName,
 				isAnimated,
 				emojis,
 				accessibilityLabel,
-				isLottie,
-				mimetype: isLottie ? 'application/was' : 'image/webp'
+				isLottie: false,
+				mimetype: 'image/webp'
 			}
 
 			metadataByHash.set(fileName, metadata)
@@ -725,22 +636,10 @@ export const prepareStickerPackMessage = async (
 		logger?.trace('Processing cover image')
 		coverBuffer = await mediaToBuffer(cover, 'cover image')
 
-		// Tray icon uses PNG format, 96x96 pixels (official client standard)
-		const lib = await getImageProcessingLibrary()
-		if (!lib?.sharp) {
-			throw new Boom(
-				'Sharp library is required for cover/tray icon processing. Install with: yarn add sharp',
-				{ statusCode: 400 }
-			)
-		}
-
-		coverWebP = await lib.sharp
-			.default(coverBuffer)
-			.resize(96, 96, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
-			.png()
-			.toBuffer()
-
-		coverFileName = `${stickerPackId}.png`
+		// Converte cover para WebP e adiciona ao ZIP
+		const result = await convertToWebP(coverBuffer, logger)
+		coverWebP = result.webpBuffer
+		coverFileName = `${stickerPackId}.webp`
 		stickerData[coverFileName] = [new Uint8Array(coverWebP), { level: 0 as 0 }]
 	} catch (error) {
 		throw new Boom(`Failed to process cover image: ${(error as Error).message}`, {