@bellaxchuu/flowred 0.8.6

package/lib/Utils/auth-utils.js

@@ -0,0 +1,306 @@
+'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')
+/**
+ * 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
+ */
+function makeCacheableSignalKeyStore(store, logger, _cache) {
+	const cache =
+		_cache ||
+		new node_cache_1.default({
+			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
+			useClones: false,
+			deleteOnExpire: true
+		})
+	// Mutex for protecting cache operations
+	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
+							// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+							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?.()
+		}
+	}
+}
+/**
+ * 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 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())
+			txMutexRefCounts.set(key, 0)
+		}
+		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()) {
+				txMutexes.delete(key)
+				txMutexRefCounts.delete(key)
+			}
+		}
+	}
+	/**
+	 * Check if currently in a transaction
+	 */
+	function isInTransaction() {
+		return !!txStorage.getStore()
+	}
+	/**
+	 * Commit transaction with retries
+	 */
+	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 = txStorage.getStore()
+			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]
+				if (value !== undefined && value !== null) {
+					result[id] = value
+				}
+			}
+			return result
+		},
+		set: async data => {
+			const ctx = txStorage.getStore()
+			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 () => {
+							const typeData = { [type]: data[type] }
+							await state.set(typeData)
+						})
+					)
+				)
+				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])
+				}
+			}
+		},
+		isInTransaction,
+		transaction: async (work, key) => {
+			const existing = txStorage.getStore()
+			// Nested transaction - reuse existing context
+			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 = {
+						cache: {},
+						mutations: {},
+						dbQueries: 0
+					}
+					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
+					} 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

@@ -0,0 +1,114 @@
+'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' //chrome
+}
+exports.getPlatformId = getPlatformId

package/lib/Utils/business.js

@@ -0,0 +1,247 @@
+'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
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
+	product = {
+		...product,
+		images: product.images
+			? await (0, exports.uploadingNecessaryImages)(product.images, waUploadToServer, timeoutMs)
+			: product.images
+	}
+	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 => {
+			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'
+	}
+}