@badzz88/baileys 8.5.3 → 8.5.4

package/lib/Utils/auth-utils.js

@@ -16,21 +16,25 @@ const Defaults_1 = require('../Defaults')
 const crypto_2 = require('./crypto')
 const generics_1 = require('./generics')
 const pre_key_manager_1 = require('./pre-key-manager')
-/**
- * Adds caching capability to a SignalKeyStore
- * @param store the store to add caching to
- * @param logger to log trace events
- * @param _cache cache store to use
- */
+
+
+
+
+
+
+
+
+const sharedTxStorage = new async_hooks_1.AsyncLocalStorage()
+
 function makeCacheableSignalKeyStore(store, logger, _cache) {
 	const cache =
 		_cache ||
 		new node_cache_1.default({
-			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
+			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE, 
 			useClones: false,
 			deleteOnExpire: true
 		})
-	// Mutex for protecting cache operations
+	
 	const cacheMutex = new async_mutex_1.Mutex()
 	function getUniqueId(type, id) {
 		return `${type}.${id}`
@@ -55,7 +59,7 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
 						const item = fetched[id]
 						if (item) {
 							data[id] = item
-							// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+							
 							await cache.set(getUniqueId(type, id), item)
 						}
 					}
@@ -82,34 +86,32 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
 		}
 	}
 }
-/**
- * Adds DB-like transaction capability to the SignalKeyStore
- * Uses AsyncLocalStorage for automatic context management
- * @param state the key store to apply this capability to
- * @param logger logger to log events
- * @returns SignalKeyStore with transaction capability
- */
+
 const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
-	const txStorage = new async_hooks_1.AsyncLocalStorage()
-	// Queues for concurrency control (keyed by signal data type - bounded set)
+	const txStorage = sharedTxStorage
+	
+	
+	
+	const storeToken = Symbol('addTransactionCapability')
+	const getOwnStore = () => {
+		const ctx = txStorage.getStore()
+		return ctx && ctx.token === storeToken ? ctx : undefined
+	}
+	
 	const keyQueues = new Map()
-	// Transaction mutexes with reference counting for cleanup
+	
 	const txMutexes = new Map()
 	const txMutexRefCounts = new Map()
-	// Pre-key manager for specialized operations
+	
 	const preKeyManager = new pre_key_manager_1.PreKeyManager(state, logger)
-	/**
-	 * Get or create a queue for a specific key type
-	 */
+	
 	function getQueue(key) {
 		if (!keyQueues.has(key)) {
 			keyQueues.set(key, new p_queue_1.default({ concurrency: 1 }))
 		}
 		return keyQueues.get(key)
 	}
-	/**
-	 * Get or create a transaction mutex
-	 */
+	
 	function getTxMutex(key) {
 		if (!txMutexes.has(key)) {
 			txMutexes.set(key, new async_mutex_1.Mutex())
@@ -117,20 +119,16 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
 		}
 		return txMutexes.get(key)
 	}
-	/**
-	 * Acquire a reference to a transaction mutex
-	 */
+	
 	function acquireTxMutexRef(key) {
 		const count = txMutexRefCounts.get(key) ?? 0
 		txMutexRefCounts.set(key, count + 1)
 	}
-	/**
-	 * Release a reference to a transaction mutex and cleanup if no longer needed
-	 */
+	
 	function releaseTxMutexRef(key) {
 		const count = (txMutexRefCounts.get(key) ?? 1) - 1
 		txMutexRefCounts.set(key, count)
-		// Cleanup if no more references and mutex is not locked
+		
 		if (count <= 0) {
 			const mutex = txMutexes.get(key)
 			if (mutex && !mutex.isLocked()) {
@@ -139,15 +137,11 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
 			}
 		}
 	}
-	/**
-	 * Check if currently in a transaction
-	 */
+	
 	function isInTransaction() {
-		return !!txStorage.getStore()
+		return !!getOwnStore()
 	}
-	/**
-	 * Commit transaction with retries
-	 */
+	
 	async function commitWithRetry(mutations) {
 		if (Object.keys(mutations).length === 0) {
 			logger.trace('no mutations in transaction')
@@ -171,23 +165,23 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
 	}
 	return {
 		get: async (type, ids) => {
-			const ctx = txStorage.getStore()
+			const ctx = getOwnStore()
 			if (!ctx) {
-				// No transaction - direct read without exclusive lock for concurrency
+				
 				return state.get(type, ids)
 			}
-			// In transaction - check cache first
+			
 			const cached = ctx.cache[type] || {}
 			const missing = ids.filter(id => !(id in cached))
 			if (missing.length > 0) {
 				ctx.dbQueries++
 				logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction')
 				const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing))
-				// Update cache
+				
 				ctx.cache[type] = ctx.cache[type] || {}
 				Object.assign(ctx.cache[type], fetched)
 			}
-			// Return requested ids from cache
+			
 			const result = {}
 			for (const id of ids) {
 				const value = ctx.cache[type]?.[id]
@@ -198,18 +192,18 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
 			return result
 		},
 		set: async data => {
-			const ctx = txStorage.getStore()
+			const ctx = getOwnStore()
 			if (!ctx) {
-				// No transaction - direct write with queue protection
+				
 				const types = Object.keys(data)
-				// Process pre-keys with validation
+				
 				for (const type_ of types) {
 					const type = type_
 					if (type === 'pre-key') {
 						await preKeyManager.validateDeletions(data, type)
 					}
 				}
-				// Write all data in parallel
+				
 				await Promise.all(
 					types.map(type =>
 						getQueue(type).add(async () => {
@@ -220,18 +214,18 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
 				)
 				return
 			}
-			// In transaction - update cache and mutations
+			
 			logger.trace({ types: Object.keys(data) }, 'caching in transaction')
 			for (const key_ in data) {
 				const key = key_
-				// Ensure structures exist
+				
 				ctx.cache[key] = ctx.cache[key] || {}
 				ctx.mutations[key] = ctx.mutations[key] || {}
-				// Special handling for pre-keys
+				
 				if (key === 'pre-key') {
 					await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true)
 				} else {
-					// Normal key types
+					
 					Object.assign(ctx.cache[key], data[key])
 					Object.assign(ctx.mutations[key], data[key])
 				}
@@ -239,18 +233,19 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
 		},
 		isInTransaction,
 		transaction: async (work, key) => {
-			const existing = txStorage.getStore()
-			// Nested transaction - reuse existing context
+			const existing = getOwnStore()
+			
 			if (existing) {
 				logger.trace('reusing existing transaction context')
 				return work()
 			}
-			// New transaction - acquire mutex and create context
+			
 			const mutex = getTxMutex(key)
 			acquireTxMutexRef(key)
 			try {
 				return await mutex.runExclusive(async () => {
 					const ctx = {
+						token: storeToken,
 						cache: {},
 						mutations: {},
 						dbQueries: 0
@@ -258,7 +253,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
 					logger.trace('entering transaction')
 					try {
 						const result = await txStorage.run(ctx, work)
-						// Commit mutations
+						
 						await commitWithRetry(ctx.mutations)
 						logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed')
 						return result

package/lib/Utils/browser-utils.js

@@ -109,6 +109,6 @@ exports.Browsers = {
 }
 const getPlatformId = browser => {
 	const platformType = index_js_1.proto.DeviceProps.PlatformType[browser.toUpperCase()]
-	return platformType ? platformType.toString() : '1' //chrome
+	return platformType ? platformType.toString() : '1' 
 }
 exports.getPlatformId = getPlatformId

package/lib/Utils/business.js

@@ -186,9 +186,7 @@ const parseProductNode = productNode => {
 	return product
 }
 exports.parseProductNode = parseProductNode
-/**
- * Uploads images not already uploaded to WA's servers
- */
+
 async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
 	product = {
 		...product,
@@ -198,9 +196,7 @@ async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, time
 	}
 	return product
 }
-/**
- * Uploads images not already uploaded to WA's servers
- */
+
 const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 30000) => {
 	const results = await Promise.all(
 		images.map(async img => {

package/lib/Utils/chat-utils.js

@@ -13,6 +13,7 @@ exports.processSyncAction =
 	exports.newLTHashState =
 		void 0
 const boom_1 = require('@hapi/boom')
+const whatsapp_rust_bridge_1 = require('whatsapp-rust-bridge')
 const index_js_1 = require('../../WAProto/index.js')
 const LabelAssociation_1 = require('../Types/LabelAssociation')
 const WABinary_1 = require('../WABinary')
@@ -22,16 +23,13 @@ const lt_hash_1 = require('./lt-hash')
 const messages_media_1 = require('./messages-media')
 const sync_action_utils_1 = require('./sync-action-utils')
 const mutationKeys = keydata => {
-	// app-state mutation keys are just HKDF-expanded sub-keys of a single 32-byte
-	// key, no elliptic-curve math involved -- this is the standard derivation
-	// used across the Baileys ecosystem.
-	const expanded = (0, crypto_1.hkdf)(keydata, 160, { info: 'WhatsApp Mutation Keys' })
+	const keys = (0, whatsapp_rust_bridge_1.expandAppStateKeys)(keydata)
 	return {
-		indexKey: expanded.subarray(0, 32),
-		valueEncryptionKey: expanded.subarray(32, 64),
-		valueMacKey: expanded.subarray(64, 96),
-		snapshotMacKey: expanded.subarray(96, 128),
-		patchMacKey: expanded.subarray(128, 160)
+		indexKey: keys.indexKey,
+		valueEncryptionKey: keys.valueEncryptionKey,
+		valueMacKey: keys.valueMacKey,
+		snapshotMacKey: keys.snapshotMacKey,
+		patchMacKey: keys.patchMacKey
 	}
 }
 const generateMac = (operation, data, keyId, key) => {
@@ -66,11 +64,11 @@ const makeLtHashGenerator = ({ indexValueMap, hash }) => {
 				if (!prevOp) {
 					throw new boom_1.Boom('tried remove, but no previous op', { data: { indexMac, valueMac } })
 				}
-				// remove from index value mac, since this mutation is erased
+				
 				delete indexValueMap[indexMacBase64]
 			} else {
 				addBuffs.push(valueMac)
-				// add this index into the history map
+				
 				indexValueMap[indexMacBase64] = { valueMac }
 			}
 			if (prevOp) {
@@ -137,7 +135,7 @@ const encodeSyncdPatch = async (
 	const encValue = (0, crypto_1.aesEncrypt)(encoded, keyValue.valueEncryptionKey)
 	const valueMac = generateMac(operation, encValue, encKeyId, keyValue.valueMacKey)
 	const indexMac = (0, crypto_1.hmacSign)(indexBuffer, keyValue.indexKey)
-	// update LT hash
+	
 	const generator = makeLtHashGenerator(state)
 	generator.mix({ indexMac, valueMac, operation })
 	Object.assign(state, generator.finish())
@@ -170,12 +168,12 @@ exports.encodeSyncdPatch = encodeSyncdPatch
 const decodeSyncdMutations = async (msgMutations, initialState, getAppStateSyncKey, onMutation, validateMacs) => {
 	const ltGenerator = makeLtHashGenerator(initialState)
 	const derivedKeyCache = new Map()
-	// indexKey used to HMAC sign record.index.blob
-	// valueEncryptionKey used to AES-256-CBC encrypt record.value.blob[0:-32]
-	// the remaining record.value.blob[0:-32] is the mac, it the HMAC sign of key.keyId + decoded proto data + length of bytes in keyId
+	
+	
+	
 	for (const msgMutation of msgMutations) {
-		// if it's a syncdmutation, get the operation property
-		// otherwise, if it's only a record -- it'll be a SET mutation
+		
+		
 		const operation =
 			'operation' in msgMutation ? msgMutation.operation : index_js_1.proto.SyncdMutation.SyncdOperation.SET
 		const record = 'record' in msgMutation && !!msgMutation.record ? msgMutation.record : msgMutation
@@ -399,7 +397,7 @@ const decodePatches = async (
 				throw new boom_1.Boom(`failed to verify LTHash at ${newState.version} of ${name}`)
 			}
 		}
-		// clear memory used up by the mutations
+		
 		syncd.mutations = []
 	}
 	return { state: newState, mutationMap }
@@ -497,7 +495,7 @@ const chatModificationToAppPatch = (mod, jid) => {
 					messageRange: getMessageRange(mod.lastMessages)
 				}
 			},
-			index: ['clearChat', jid, '1' /*the option here is 0 when keep starred messages is enabled*/, '0'],
+			index: ['clearChat', jid, '1' , '0'],
 			type: 'regular_high',
 			apiVersion: 6,
 			operation: OP.SET
@@ -843,6 +841,45 @@ const chatModificationToAppPatch = (mod, jid) => {
 			apiVersion: 1,
 			operation: OP.SET
 		}
+	} else if ('externalWebBeta' in mod) {
+		patch = {
+			syncAction: {
+				externalWebBetaAction: { isOptIn: !!mod.externalWebBeta }
+			},
+			index: ['setting_external_web_beta'],
+			type: 'regular',
+			apiVersion: 1,
+			operation: OP.SET
+		}
+	} else if ('maibaAIFeatures' in mod) {
+		const statusEnum = index_js_1.proto.SyncActionValue.MaibaAIFeaturesControlAction.MaibaAIFeatureStatus
+		const replyModeEnum = index_js_1.proto.SyncActionValue.MaibaAIFeaturesControlAction.MaibaAIReplyMode
+		const statusMap = {
+			enabled: statusEnum.ENABLED,
+			enabled_has_learning: statusEnum.ENABLED_HAS_LEARNING,
+			disabled: statusEnum.DISABLED
+		}
+		const replyModeMap = {
+			muted: replyModeEnum.MUTED,
+			ai_agent: replyModeEnum.AI_AGENT,
+			suggestions: replyModeEnum.SUGGESTIONS
+		}
+		const aiFeatures = mod.maibaAIFeatures
+		const status =
+			typeof aiFeatures.status === 'string' ? (statusMap[aiFeatures.status] ?? statusEnum.ENABLED) : aiFeatures.status
+		const replyMode =
+			typeof aiFeatures.replyMode === 'string'
+				? (replyModeMap[aiFeatures.replyMode] ?? replyModeEnum.SUGGESTIONS)
+				: aiFeatures.replyMode
+		patch = {
+			syncAction: {
+				maibaAiFeaturesControlAction: { aiFeatureStatus: status, aiReplyMode: replyMode }
+			},
+			index: ['setting_maiba_ai'],
+			type: 'regular',
+			apiVersion: 1,
+			operation: OP.SET
+		}
 	} else {
 		throw new boom_1.Boom('not supported')
 	}
@@ -867,25 +904,25 @@ const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) => {
 			}
 		])
 	} else if (action?.archiveChatAction || type === 'archive' || type === 'unarchive') {
-		// okay so we've to do some annoying computation here
-		// when we're initially syncing the app state
-		// there are a few cases we need to handle
-		// 1. if the account unarchiveChats setting is true
-		//   a. if the chat is archived, and no further messages have been received -- simple, keep archived
-		//   b. if the chat was archived, and the user received messages from the other person afterwards
-		//		then the chat should be marked unarchved --
-		//		we compare the timestamp of latest message from the other person to determine this
-		// 2. if the account unarchiveChats setting is false -- then it doesn't matter,
-		//	it'll always take an app state action to mark in unarchived -- which we'll get anyway
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		
 		const archiveAction = action?.archiveChatAction
 		const isArchived = archiveAction ? archiveAction.archived : type === 'archive'
-		// // basically we don't need to fire an "archive" update if the chat is being marked unarchvied
-		// // this only applies for the initial sync
-		// if(isInitialSync && !isArchived) {
-		// 	isArchived = false
-		// }
+		
+		
+		
+		
+		
 		const msgRange = !accountSettings?.unarchiveChats ? undefined : archiveAction?.messageRange
-		// logger?.debug({ chat: id, syncAction }, 'message range archive')
+		
 		ev.emit('chats.update', [
 			{
 				id,
@@ -895,9 +932,9 @@ const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) => {
 		])
 	} else if (action?.markChatAsReadAction) {
 		const markReadAction = action.markChatAsReadAction
-		// basically we don't need to fire an "read" update if the chat is being marked as read
-		// because the chat is read by default
-		// this only applies for the initial sync
+		
+		
+		
 		const isNullUpdate = isInitialSync && markReadAction.read
 		ev.emit('chats.update', [
 			{
@@ -1186,6 +1223,33 @@ const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) => {
 		ev.emit('settings.update', { setting: 'businessBroadcastInsights', value: action.businessBroadcastInsightsAction })
 	} else if (action?.bizAiSettingsNudgeAction) {
 		ev.emit('settings.update', { setting: 'bizAiSettingsNudge', value: action.bizAiSettingsNudgeAction })
+	} else if (action?.clearChatAction) {
+		ev.emit('chats.update', [
+			{
+				id,
+				lastMessageRecvTimestamp: 0,
+				conditional: getChatUpdateConditional(id, action.clearChatAction?.messageRange)
+			}
+		])
+	} else if (action?.deviceCapabilities) {
+		ev.emit('settings.update', { setting: 'deviceCapabilities', value: action.deviceCapabilities })
+	} else if (action?.ugcBot) {
+		ev.emit('settings.update', { setting: 'ugcBot', value: action.ugcBot })
+	} else if (action?.coexV2VersionAction) {
+		ev.emit('settings.update', { setting: 'coexV2Version', value: action.coexV2VersionAction })
+	} else if (action?.wasaRootSecretAction) {
+		ev.emit('settings.update', { setting: 'wasaRootSecret', value: action.wasaRootSecretAction })
+	} else if (action?.bubbleLockMessageAction) {
+		ev.emit('messages.update', [
+			{
+				key: { remoteJid: id, id: msgId, fromMe: fromMe === '1' },
+				update: { bubbleLocked: action.bubbleLockMessageAction?.locked }
+			}
+		])
+	} else if (action?.labelSublistAction) {
+		ev.emit('chats.update', [
+			{ id, labelSublistId: action.labelSublistAction?.subListId, conditional: getChatUpdateConditional(id, undefined) }
+		])
 	} else {
 		logger?.debug({ syncAction, id }, 'unprocessable update')
 	}