@badzz88/baileys 8.5.4 → 8.5.6

package/lib/Utils/auth-utils.js

@@ -1,301 +0,0 @@
-'use strict'
-var __importDefault =
-	(this && this.__importDefault) ||
-	function (mod) {
-		return mod && mod.__esModule ? mod : { default: mod }
-	}
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.initAuthCreds = exports.addTransactionCapability = void 0
-exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore
-const node_cache_1 = __importDefault(require('@cacheable/node-cache'))
-const async_hooks_1 = require('async_hooks')
-const async_mutex_1 = require('async-mutex')
-const crypto_1 = require('crypto')
-const p_queue_1 = __importDefault(require('p-queue'))
-const Defaults_1 = require('../Defaults')
-const crypto_2 = require('./crypto')
-const generics_1 = require('./generics')
-const pre_key_manager_1 = require('./pre-key-manager')
-
-
-
-
-
-
-
-
-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, 
-			useClones: false,
-			deleteOnExpire: true
-		})
-	
-	const cacheMutex = new async_mutex_1.Mutex()
-	function getUniqueId(type, id) {
-		return `${type}.${id}`
-	}
-	return {
-		async get(type, ids) {
-			return cacheMutex.runExclusive(async () => {
-				const data = {}
-				const idsToFetch = []
-				for (const id of ids) {
-					const item = await cache.get(getUniqueId(type, id))
-					if (typeof item !== 'undefined') {
-						data[id] = item
-					} else {
-						idsToFetch.push(id)
-					}
-				}
-				if (idsToFetch.length) {
-					logger?.trace({ items: idsToFetch.length }, 'loading from store')
-					const fetched = await store.get(type, idsToFetch)
-					for (const id of idsToFetch) {
-						const item = fetched[id]
-						if (item) {
-							data[id] = item
-							
-							await cache.set(getUniqueId(type, id), item)
-						}
-					}
-				}
-				return data
-			})
-		},
-		async set(data) {
-			return cacheMutex.runExclusive(async () => {
-				let keys = 0
-				for (const type in data) {
-					for (const id in data[type]) {
-						await cache.set(getUniqueId(type, id), data[type][id])
-						keys += 1
-					}
-				}
-				logger?.trace({ keys }, 'updated cache')
-				await store.set(data)
-			})
-		},
-		async clear() {
-			await cache.flushAll()
-			await store.clear?.()
-		}
-	}
-}
-
-const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
-	const txStorage = sharedTxStorage
-	
-	
-	
-	const storeToken = Symbol('addTransactionCapability')
-	const getOwnStore = () => {
-		const ctx = txStorage.getStore()
-		return ctx && ctx.token === storeToken ? ctx : undefined
-	}
-	
-	const keyQueues = new Map()
-	
-	const txMutexes = new Map()
-	const txMutexRefCounts = new Map()
-	
-	const preKeyManager = new pre_key_manager_1.PreKeyManager(state, logger)
-	
-	function getQueue(key) {
-		if (!keyQueues.has(key)) {
-			keyQueues.set(key, new p_queue_1.default({ concurrency: 1 }))
-		}
-		return keyQueues.get(key)
-	}
-	
-	function getTxMutex(key) {
-		if (!txMutexes.has(key)) {
-			txMutexes.set(key, new async_mutex_1.Mutex())
-			txMutexRefCounts.set(key, 0)
-		}
-		return txMutexes.get(key)
-	}
-	
-	function acquireTxMutexRef(key) {
-		const count = txMutexRefCounts.get(key) ?? 0
-		txMutexRefCounts.set(key, count + 1)
-	}
-	
-	function releaseTxMutexRef(key) {
-		const count = (txMutexRefCounts.get(key) ?? 1) - 1
-		txMutexRefCounts.set(key, count)
-		
-		if (count <= 0) {
-			const mutex = txMutexes.get(key)
-			if (mutex && !mutex.isLocked()) {
-				txMutexes.delete(key)
-				txMutexRefCounts.delete(key)
-			}
-		}
-	}
-	
-	function isInTransaction() {
-		return !!getOwnStore()
-	}
-	
-	async function commitWithRetry(mutations) {
-		if (Object.keys(mutations).length === 0) {
-			logger.trace('no mutations in transaction')
-			return
-		}
-		logger.trace('committing transaction')
-		for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
-			try {
-				await state.set(mutations)
-				logger.trace({ mutationCount: Object.keys(mutations).length }, 'committed transaction')
-				return
-			} catch (error) {
-				const retriesLeft = maxCommitRetries - attempt - 1
-				logger.warn(`failed to commit mutations, retries left=${retriesLeft}`)
-				if (retriesLeft === 0) {
-					throw error
-				}
-				await (0, generics_1.delay)(delayBetweenTriesMs)
-			}
-		}
-	}
-	return {
-		get: async (type, ids) => {
-			const ctx = getOwnStore()
-			if (!ctx) {
-				
-				return state.get(type, ids)
-			}
-			
-			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))
-				
-				ctx.cache[type] = ctx.cache[type] || {}
-				Object.assign(ctx.cache[type], fetched)
-			}
-			
-			const result = {}
-			for (const id of ids) {
-				const value = ctx.cache[type]?.[id]
-				if (value !== undefined && value !== null) {
-					result[id] = value
-				}
-			}
-			return result
-		},
-		set: async data => {
-			const ctx = getOwnStore()
-			if (!ctx) {
-				
-				const types = Object.keys(data)
-				
-				for (const type_ of types) {
-					const type = type_
-					if (type === 'pre-key') {
-						await preKeyManager.validateDeletions(data, type)
-					}
-				}
-				
-				await Promise.all(
-					types.map(type =>
-						getQueue(type).add(async () => {
-							const typeData = { [type]: data[type] }
-							await state.set(typeData)
-						})
-					)
-				)
-				return
-			}
-			
-			logger.trace({ types: Object.keys(data) }, 'caching in transaction')
-			for (const key_ in data) {
-				const key = key_
-				
-				ctx.cache[key] = ctx.cache[key] || {}
-				ctx.mutations[key] = ctx.mutations[key] || {}
-				
-				if (key === 'pre-key') {
-					await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true)
-				} else {
-					
-					Object.assign(ctx.cache[key], data[key])
-					Object.assign(ctx.mutations[key], data[key])
-				}
-			}
-		},
-		isInTransaction,
-		transaction: async (work, key) => {
-			const existing = getOwnStore()
-			
-			if (existing) {
-				logger.trace('reusing existing transaction context')
-				return work()
-			}
-			
-			const mutex = getTxMutex(key)
-			acquireTxMutexRef(key)
-			try {
-				return await mutex.runExclusive(async () => {
-					const ctx = {
-						token: storeToken,
-						cache: {},
-						mutations: {},
-						dbQueries: 0
-					}
-					logger.trace('entering transaction')
-					try {
-						const result = await txStorage.run(ctx, work)
-						
-						await commitWithRetry(ctx.mutations)
-						logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed')
-						return result
-					} catch (error) {
-						logger.error({ error }, 'transaction failed, rolling back')
-						throw error
-					}
-				})
-			} finally {
-				releaseTxMutexRef(key)
-			}
-		}
-	}
-}
-exports.addTransactionCapability = addTransactionCapability
-const initAuthCreds = () => {
-	const identityKey = crypto_2.Curve.generateKeyPair()
-	return {
-		noiseKey: crypto_2.Curve.generateKeyPair(),
-		pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
-		signedIdentityKey: identityKey,
-		signedPreKey: (0, crypto_2.signedKeyPair)(identityKey, 1),
-		registrationId: (0, generics_1.generateRegistrationId)(),
-		advSecretKey: (0, crypto_1.randomBytes)(32).toString('base64'),
-		processedHistoryMessages: [],
-		initialFullSyncDone: false,
-		nextPreKeyId: 1,
-		firstUnuploadedPreKeyId: 1,
-		accountSyncCounter: 0,
-		accountSettings: {
-			unarchiveChats: false
-		},
-		deviceId: Buffer.from((0, crypto_1.randomUUID)().replace(/-/g, ''), 'hex').toString('base64url'),
-		phoneId: (0, crypto_1.randomUUID)(),
-		identityId: (0, crypto_1.randomBytes)(20),
-		backupToken: (0, crypto_1.randomBytes)(20),
-		registration: {},
-		registered: false,
-		pairingCode: undefined,
-		lastPropHash: undefined,
-		routingInfo: undefined,
-		additionalData: undefined
-	}
-}
-exports.initAuthCreds = initAuthCreds

package/lib/Utils/browser-utils.js

@@ -1,114 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.getPlatformId = exports.Browsers = void 0
-const os_1 = require('os')
-const index_js_1 = require('../../WAProto/index.js')
-const COMPANION_PLATFORM_MAP = {
-	Chrome: '49',
-	Edge: '50',
-	Firefox: '51',
-	Opera: '53',
-	Safari: '54',
-	Brave: '1.79.112',
-	Vivaldi: '6.2.3105.58',
-	Tor: '12.5.3',
-	Yandex: '23.7.1',
-	Falkon: '22.08.3',
-	Epiphany: '44.2'
-}
-const PLATFORM_MAP = {
-	aix: 'AIX',
-	darwin: 'Mac OS',
-	win32: 'Windows',
-	android: 'Android',
-	freebsd: 'FreeBSD',
-	openbsd: 'OpenBSD',
-	sunos: 'Solaris',
-	linux: 'Linux',
-	ubuntu: 'Ubuntu',
-	ios: 'iOS',
-	baileys: 'Baileys',
-	chromeos: 'Chrome OS',
-	tizen: 'Tizen',
-	watchos: 'watchOS',
-	wearos: 'Wear OS',
-	harmonyos: 'HarmonyOS',
-	kaios: 'KaiOS',
-	smarttv: 'Smart TV',
-	raspberrypi: 'Raspberry Pi OS',
-	symbian: 'Symbian',
-	blackberry: 'Blackberry OS',
-	windowsphone: 'Windows Phone',
-	safari: 'Safari'
-}
-
-const PLATFORM_VERSIONS = {
-	ubuntu: '22.04.4',
-	darwin: '18.5',
-	win32: '10.0.22631',
-	android: '14.0.0',
-	freebsd: '13.2',
-	openbsd: '7.3',
-	sunos: '11',
-	linux: '6.5',
-	ios: '18.2',
-	baileys: '6.5.0',
-	chromeos: '117.0.5938.132',
-	tizen: '6.5',
-	watchos: '10.1',
-	wearos: '4.1',
-	harmonyos: '4.0.0',
-	kaios: '3.1',
-	smarttv: '23.3.1',
-	raspberrypi: '11 (Bullseye)',
-	symbian: '3',
-	blackberry: '10.3.3',
-	windowsphone: '8.1'
-}
-
-exports.Browsers = {
-	ubuntu: browser => {
-		return [PLATFORM_MAP['ubuntu'], browser, PLATFORM_VERSIONS['ubuntu']]
-	},
-	macOS: browser => {
-		return [PLATFORM_MAP['darwin'], browser, PLATFORM_VERSIONS['darwin']]
-	},
-	windows: browser => {
-		return [PLATFORM_MAP['win32'], browser, PLATFORM_VERSIONS['win32']]
-	},
-	linux: browser => {
-		return [PLATFORM_MAP['linux'], browser, PLATFORM_VERSIONS['linux']]
-	},
-	solaris: browser => {
-		return [PLATFORM_MAP['sunos'], browser, PLATFORM_VERSIONS['sunos']]
-	},
-	baileys: browser => {
-		return [PLATFORM_MAP['baileys'], browser, PLATFORM_VERSIONS['baileys']]
-	},
-	android: browser => {
-		return [PLATFORM_MAP['android'], browser, PLATFORM_VERSIONS['android']]
-	},
-	iOS: browser => {
-		return [PLATFORM_MAP['ios'], browser, PLATFORM_VERSIONS['ios']]
-	},
-	kaiOS: browser => {
-		return [PLATFORM_MAP['kaios'], browser, PLATFORM_VERSIONS['kaios']]
-	},
-	chromeOS: browser => {
-		return [PLATFORM_MAP['chromeos'], browser, PLATFORM_VERSIONS['chromeos']]
-	},
-	appropriate: browser => {
-		const platform = os_1.platform()
-		const platformName = PLATFORM_MAP[platform] || 'Unknown OS'
-		return [platformName, browser, PLATFORM_VERSIONS[platform] || 'latest']
-	},
-	custom: (platform, browser, version) => {
-		const platformName = PLATFORM_MAP[platform.toLowerCase()] || platform
-		return [platformName, browser, version || PLATFORM_VERSIONS[platform] || 'latest']
-	}
-}
-const getPlatformId = browser => {
-	const platformType = index_js_1.proto.DeviceProps.PlatformType[browser.toUpperCase()]
-	return platformType ? platformType.toString() : '1' 
-}
-exports.getPlatformId = getPlatformId

package/lib/Utils/business.js

@@ -1,243 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.uploadingNecessaryImages =
-	exports.parseProductNode =
-	exports.toProductNode =
-	exports.parseOrderDetailsNode =
-	exports.parseCollectionsNode =
-	exports.parseCatalogNode =
-		void 0
-exports.uploadingNecessaryImagesOfProduct = uploadingNecessaryImagesOfProduct
-const boom_1 = require('@hapi/boom')
-const crypto_1 = require('crypto')
-const fs_1 = require('fs')
-const os_1 = require('os')
-const path_1 = require('path')
-const WABinary_1 = require('../WABinary')
-const generics_1 = require('./generics')
-const messages_media_1 = require('./messages-media')
-const parseCatalogNode = node => {
-	const catalogNode = (0, WABinary_1.getBinaryNodeChild)(node, 'product_catalog')
-	const products = (0, WABinary_1.getBinaryNodeChildren)(catalogNode, 'product').map(exports.parseProductNode)
-	const paging = (0, WABinary_1.getBinaryNodeChild)(catalogNode, 'paging')
-	return {
-		products,
-		nextPageCursor: paging ? (0, WABinary_1.getBinaryNodeChildString)(paging, 'after') : undefined
-	}
-}
-exports.parseCatalogNode = parseCatalogNode
-const parseCollectionsNode = node => {
-	const collectionsNode = (0, WABinary_1.getBinaryNodeChild)(node, 'collections')
-	const collections = (0, WABinary_1.getBinaryNodeChildren)(collectionsNode, 'collection').map(collectionNode => {
-		const id = (0, WABinary_1.getBinaryNodeChildString)(collectionNode, 'id')
-		const name = (0, WABinary_1.getBinaryNodeChildString)(collectionNode, 'name')
-		const products = (0, WABinary_1.getBinaryNodeChildren)(collectionNode, 'product').map(exports.parseProductNode)
-		return {
-			id,
-			name,
-			products,
-			status: parseStatusInfo(collectionNode)
-		}
-	})
-	return {
-		collections
-	}
-}
-exports.parseCollectionsNode = parseCollectionsNode
-const parseOrderDetailsNode = node => {
-	const orderNode = (0, WABinary_1.getBinaryNodeChild)(node, 'order')
-	const products = (0, WABinary_1.getBinaryNodeChildren)(orderNode, 'product').map(productNode => {
-		const imageNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'image')
-		return {
-			id: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'id'),
-			name: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'name'),
-			imageUrl: (0, WABinary_1.getBinaryNodeChildString)(imageNode, 'url'),
-			price: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'price'),
-			currency: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'currency'),
-			quantity: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'quantity')
-		}
-	})
-	const priceNode = (0, WABinary_1.getBinaryNodeChild)(orderNode, 'price')
-	const orderDetails = {
-		price: {
-			total: +(0, WABinary_1.getBinaryNodeChildString)(priceNode, 'total'),
-			currency: (0, WABinary_1.getBinaryNodeChildString)(priceNode, 'currency')
-		},
-		products
-	}
-	return orderDetails
-}
-exports.parseOrderDetailsNode = parseOrderDetailsNode
-const toProductNode = (productId, product) => {
-	const attrs = {}
-	const content = []
-	if (typeof productId !== 'undefined') {
-		content.push({
-			tag: 'id',
-			attrs: {},
-			content: Buffer.from(productId)
-		})
-	}
-	if (typeof product.name !== 'undefined') {
-		content.push({
-			tag: 'name',
-			attrs: {},
-			content: Buffer.from(product.name)
-		})
-	}
-	if (typeof product.description !== 'undefined') {
-		content.push({
-			tag: 'description',
-			attrs: {},
-			content: Buffer.from(product.description)
-		})
-	}
-	if (typeof product.retailerId !== 'undefined') {
-		content.push({
-			tag: 'retailer_id',
-			attrs: {},
-			content: Buffer.from(product.retailerId)
-		})
-	}
-	if (product.images.length) {
-		content.push({
-			tag: 'media',
-			attrs: {},
-			content: product.images.map(img => {
-				if (!('url' in img)) {
-					throw new boom_1.Boom('Expected img for product to already be uploaded', { statusCode: 400 })
-				}
-				return {
-					tag: 'image',
-					attrs: {},
-					content: [
-						{
-							tag: 'url',
-							attrs: {},
-							content: Buffer.from(img.url.toString())
-						}
-					]
-				}
-			})
-		})
-	}
-	if (typeof product.price !== 'undefined') {
-		content.push({
-			tag: 'price',
-			attrs: {},
-			content: Buffer.from(product.price.toString())
-		})
-	}
-	if (typeof product.currency !== 'undefined') {
-		content.push({
-			tag: 'currency',
-			attrs: {},
-			content: Buffer.from(product.currency)
-		})
-	}
-	if ('originCountryCode' in product) {
-		if (typeof product.originCountryCode === 'undefined') {
-			attrs['compliance_category'] = 'COUNTRY_ORIGIN_EXEMPT'
-		} else {
-			content.push({
-				tag: 'compliance_info',
-				attrs: {},
-				content: [
-					{
-						tag: 'country_code_origin',
-						attrs: {},
-						content: Buffer.from(product.originCountryCode)
-					}
-				]
-			})
-		}
-	}
-	if (typeof product.isHidden !== 'undefined') {
-		attrs['is_hidden'] = product.isHidden.toString()
-	}
-	const node = {
-		tag: 'product',
-		attrs,
-		content
-	}
-	return node
-}
-exports.toProductNode = toProductNode
-const parseProductNode = productNode => {
-	const isHidden = productNode.attrs.is_hidden === 'true'
-	const id = (0, WABinary_1.getBinaryNodeChildString)(productNode, 'id')
-	const mediaNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'media')
-	const statusInfoNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'status_info')
-	const product = {
-		id,
-		imageUrls: parseImageUrls(mediaNode),
-		reviewStatus: {
-			whatsapp: (0, WABinary_1.getBinaryNodeChildString)(statusInfoNode, 'status')
-		},
-		availability: 'in stock',
-		name: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'name'),
-		retailerId: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'retailer_id'),
-		url: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'url'),
-		description: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'description'),
-		price: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'price'),
-		currency: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'currency'),
-		isHidden
-	}
-	return product
-}
-exports.parseProductNode = parseProductNode
-
-async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
-	product = {
-		...product,
-		images: product.images
-			? await (0, exports.uploadingNecessaryImages)(product.images, waUploadToServer, timeoutMs)
-			: product.images
-	}
-	return product
-}
-
-const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 30000) => {
-	const results = await Promise.all(
-		images.map(async img => {
-			if ('url' in img) {
-				const url = img.url.toString()
-				if (url.includes('.whatsapp.net')) {
-					return { url }
-				}
-			}
-			const { stream } = await (0, messages_media_1.getStream)(img)
-			const hasher = (0, crypto_1.createHash)('sha256')
-			const filePath = (0, path_1.join)((0, os_1.tmpdir)(), 'img' + (0, generics_1.generateMessageIDV2)())
-			const encFileWriteStream = (0, fs_1.createWriteStream)(filePath)
-			for await (const block of stream) {
-				hasher.update(block)
-				encFileWriteStream.write(block)
-			}
-			const sha = hasher.digest('base64')
-			const { directPath } = await waUploadToServer(filePath, {
-				mediaType: 'product-catalog-image',
-				fileEncSha256B64: sha,
-				timeoutMs
-			})
-			await fs_1.promises.unlink(filePath).catch(() => {})
-			return { url: (0, messages_media_1.getUrlFromDirectPath)(directPath) }
-		})
-	)
-	return results
-}
-exports.uploadingNecessaryImages = uploadingNecessaryImages
-const parseImageUrls = mediaNode => {
-	const imgNode = (0, WABinary_1.getBinaryNodeChild)(mediaNode, 'image')
-	return {
-		requested: (0, WABinary_1.getBinaryNodeChildString)(imgNode, 'request_image_url'),
-		original: (0, WABinary_1.getBinaryNodeChildString)(imgNode, 'original_image_url')
-	}
-}
-const parseStatusInfo = mediaNode => {
-	const node = (0, WABinary_1.getBinaryNodeChild)(mediaNode, 'status_info')
-	return {
-		status: (0, WABinary_1.getBinaryNodeChildString)(node, 'status'),
-		canAppeal: (0, WABinary_1.getBinaryNodeChildString)(node, 'can_appeal') === 'true'
-	}
-}