@badzz88/baileys 8.5.4 → 8.5.6

package/lib/Utils/reporting-utils.js

@@ -1,262 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.getMessageReportingToken = exports.shouldIncludeReportingToken = void 0
-const rb = require('whatsapp-rust-bridge')
-const crypto_2 = require('./crypto')
-const reportingFields = [
-	{ f: 1 },
-	{
-		f: 3,
-		s: [{ f: 2 }, { f: 3 }, { f: 8 }, { f: 11 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 25 }]
-	},
-	{ f: 4, s: [{ f: 1 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
-	{ f: 5, s: [{ f: 3 }, { f: 4 }, { f: 5 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
-	{ f: 6, s: [{ f: 1 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 30 }] },
-	{ f: 7, s: [{ f: 2 }, { f: 7 }, { f: 10 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
-	{ f: 8, s: [{ f: 2 }, { f: 7 }, { f: 9 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 21 }] },
-	{ f: 9, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
-	{ f: 12, s: [{ f: 1 }, { f: 2 }, { f: 14, m: true }, { f: 15 }] },
-	{ f: 18, s: [{ f: 6 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
-	{ f: 26, s: [{ f: 4 }, { f: 5 }, { f: 8 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
-	{ f: 28, s: [{ f: 1 }, { f: 2 }, { f: 4 }, { f: 5 }, { f: 6 }, { f: 7, s: [{ f: 21 }, { f: 22 }] }] },
-	{ f: 37, s: [{ f: 1, m: true }] },
-	{
-		f: 49,
-		s: [
-			{ f: 2 },
-			{ f: 3, s: [{ f: 1 }, { f: 2 }] },
-			{ f: 5, s: [{ f: 21 }, { f: 22 }] },
-			{ f: 8, s: [{ f: 1 }, { f: 2 }] }
-		]
-	},
-	{ f: 53, s: [{ f: 1, m: true }] },
-	{ f: 55, s: [{ f: 1, m: true }] },
-	{ f: 58, s: [{ f: 1, m: true }] },
-	{ f: 59, s: [{ f: 1, m: true }] },
-	{
-		f: 60,
-		s: [
-			{ f: 2 },
-			{ f: 3, s: [{ f: 1 }, { f: 2 }] },
-			{ f: 5, s: [{ f: 21 }, { f: 22 }] },
-			{ f: 8, s: [{ f: 1 }, { f: 2 }] }
-		]
-	},
-	{
-		f: 64,
-		s: [
-			{ f: 2 },
-			{ f: 3, s: [{ f: 1 }, { f: 2 }] },
-			{ f: 5, s: [{ f: 21 }, { f: 22 }] },
-			{ f: 8, s: [{ f: 1 }, { f: 2 }] }
-		]
-	},
-	{ f: 66, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
-	{ f: 74, s: [{ f: 1, m: true }] },
-	{ f: 87, s: [{ f: 1, m: true }] },
-	{ f: 88, s: [{ f: 1 }, { f: 2, s: [{ f: 1 }] }, { f: 3, s: [{ f: 21 }, { f: 22 }] }] },
-	{ f: 92, s: [{ f: 1, m: true }] },
-	{ f: 93, s: [{ f: 1, m: true }] },
-	{ f: 94, s: [{ f: 1, m: true }] }
-]
-const compileReportingFields = fields => {
-	const map = new Map()
-	for (const f of fields) {
-		map.set(f.f, {
-			m: f.m,
-			children: f.s ? compileReportingFields(f.s) : undefined
-		})
-	}
-	return map
-}
-const compiledReportingFields = compileReportingFields(reportingFields)
-const EMPTY_MAP = new Map()
-const ENC_SECRET_REPORT_TOKEN = 'Report Token'
-const WIRE = {
-	VARINT: 0,
-	FIXED64: 1,
-	BYTES: 2,
-	FIXED32: 5
-}
-const shouldIncludeReportingToken = message =>
-	!message.reactionMessage &&
-	!message.encReactionMessage &&
-	!message.encEventResponseMessage &&
-	!message.pollUpdateMessage
-exports.shouldIncludeReportingToken = shouldIncludeReportingToken
-const generateMsgSecretKey = (modificationType, origMsgId, origMsgSender, modificationSender, origMsgSecret) => {
-	const useCaseSecret = Buffer.concat([
-		Buffer.from(origMsgId, 'utf8'),
-		Buffer.from(origMsgSender, 'utf8'),
-		Buffer.from(modificationSender, 'utf8'),
-		Buffer.from(modificationType, 'utf8')
-	])
-	return (0, crypto_2.hkdf)(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') })
-}
-const extractReportingTokenContent = (data, cfg) => {
-	const out = []
-	let i = 0
-	while (i < data.length) {
-		const tag = decodeVarint(data, i)
-		if (!tag.ok) {
-			return null
-		}
-		const fieldNum = tag.value >> 3
-		const wireType = tag.value & 0x7
-		const fieldStart = i
-		i += tag.bytes
-		const fieldCfg = cfg.get(fieldNum)
-		const pushSlice = end => {
-			if (end > data.length) {
-				return false
-			}
-			out.push({ num: fieldNum, bytes: data.subarray(fieldStart, end) })
-			i = end
-			return true
-		}
-		const skip = end => {
-			if (end > data.length) {
-				return false
-			}
-			i = end
-			return true
-		}
-		if (wireType === WIRE.VARINT) {
-			const v = decodeVarint(data, i)
-			if (!v.ok) {
-				return null
-			}
-			const end = i + v.bytes
-			if (!fieldCfg) {
-				if (!skip(end)) {
-					return null
-				}
-				continue
-			}
-			if (!pushSlice(end)) {
-				return null
-			}
-			continue
-		}
-		if (wireType === WIRE.FIXED64) {
-			const end = i + 8
-			if (!fieldCfg) {
-				if (!skip(end)) {
-					return null
-				}
-				continue
-			}
-			if (!pushSlice(end)) {
-				return null
-			}
-			continue
-		}
-		if (wireType === WIRE.FIXED32) {
-			const end = i + 4
-			if (!fieldCfg) {
-				if (!skip(end)) {
-					return null
-				}
-				continue
-			}
-			if (!pushSlice(end)) {
-				return null
-			}
-			continue
-		}
-		if (wireType === WIRE.BYTES) {
-			const len = decodeVarint(data, i)
-			if (!len.ok) {
-				return null
-			}
-			const valStart = i + len.bytes
-			const valEnd = valStart + len.value
-			if (valEnd > data.length) {
-				return null
-			}
-			if (!fieldCfg) {
-				i = valEnd
-				continue
-			}
-			if (fieldCfg.m || fieldCfg.children) {
-				const sub = extractReportingTokenContent(data.subarray(valStart, valEnd), fieldCfg.children ?? EMPTY_MAP)
-				if (sub === null) {
-					return null
-				}
-				if (sub.length > 0) {
-					const newTag = encodeVarint(tag.value)
-					const newLen = encodeVarint(sub.length)
-					out.push({
-						num: fieldNum,
-						bytes: Buffer.concat([newTag, newLen, sub])
-					})
-				}
-				i = valEnd
-				continue
-			}
-			out.push({ num: fieldNum, bytes: data.subarray(fieldStart, valEnd) })
-			i = valEnd
-			continue
-		}
-		return null
-	}
-	if (out.length === 0) {
-		return Buffer.alloc(0)
-	}
-	out.sort((a, b) => a.num - b.num)
-	return Buffer.concat(out.map(f => f.bytes))
-}
-const decodeVarint = (buffer, offset) => {
-	let value = 0
-	let bytes = 0
-	let shift = 0
-	while (offset + bytes < buffer.length) {
-		const current = buffer[offset + bytes]
-		value |= (current & 0x7f) << shift
-		bytes++
-		if ((current & 0x80) === 0) {
-			return { value, bytes, ok: true }
-		}
-		shift += 7
-		if (shift > 35) {
-			return { value: 0, bytes: 0, ok: false }
-		}
-	}
-	return { value: 0, bytes: 0, ok: false }
-}
-const encodeVarint = value => {
-	const parts = []
-	let remaining = value >>> 0
-	while (remaining > 0x7f) {
-		parts.push((remaining & 0x7f) | 0x80)
-		remaining >>>= 7
-	}
-	parts.push(remaining)
-	return Buffer.from(parts)
-}
-const getMessageReportingToken = async (msgProtobuf, message, key) => {
-	const msgSecret = message.messageContextInfo?.messageSecret
-	if (!msgSecret || !key.id) {
-		return null
-	}
-	const from = key.fromMe ? key.remoteJid : key.participant || key.remoteJid
-	const to = key.fromMe ? key.participant || key.remoteJid : key.remoteJid
-	const reportingSecret = generateMsgSecretKey(ENC_SECRET_REPORT_TOKEN, key.id, from, to, msgSecret)
-	const content = extractReportingTokenContent(msgProtobuf, compiledReportingFields)
-	if (!content || content.length === 0) {
-		return null
-	}
-	const reportingToken = Buffer.from(rb.hmacSign(content, reportingSecret)).subarray(0, 16)
-	return {
-		tag: 'reporting',
-		attrs: {},
-		content: [
-			{
-				tag: 'reporting_token',
-				attrs: { v: '2' },
-				content: reportingToken
-			}
-		]
-	}
-}
-exports.getMessageReportingToken = getMessageReportingToken

package/lib/Utils/signal.js

@@ -1,189 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.getNextPreKeysNode =
-	exports.getNextPreKeys =
-	exports.extractDeviceJids =
-	exports.parseAndInjectE2ESessions =
-	exports.xmppPreKey =
-	exports.xmppSignedPreKey =
-	exports.generateOrGetPreKeys =
-	exports.getPreKeys =
-	exports.createSignalIdentity =
-		void 0
-const Defaults_1 = require('../Defaults')
-const WABinary_1 = require('../WABinary')
-const crypto_1 = require('./crypto')
-const generics_1 = require('./generics')
-function chunk(array, size) {
-	const chunks = []
-	for (let i = 0; i < array.length; i += size) {
-		chunks.push(array.slice(i, i + size))
-	}
-	return chunks
-}
-const createSignalIdentity = (wid, accountSignatureKey) => {
-	return {
-		identifier: { name: wid, deviceId: 0 },
-		identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
-	}
-}
-exports.createSignalIdentity = createSignalIdentity
-const getPreKeys = async ({ get }, min, limit) => {
-	const idList = []
-	for (let id = min; id < limit; id++) {
-		idList.push(id.toString())
-	}
-	return get('pre-key', idList)
-}
-exports.getPreKeys = getPreKeys
-const generateOrGetPreKeys = (creds, range) => {
-	const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
-	const remaining = range - avaliable
-	const lastPreKeyId = creds.nextPreKeyId + remaining - 1
-	const newPreKeys = {}
-	if (remaining > 0) {
-		for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-			newPreKeys[i] = crypto_1.Curve.generateKeyPair()
-		}
-	}
-	return {
-		newPreKeys,
-		lastPreKeyId,
-		preKeysRange: [creds.firstUnuploadedPreKeyId, range]
-	}
-}
-exports.generateOrGetPreKeys = generateOrGetPreKeys
-
-
-const xmppSignedPreKey = (key, cipherSuite) => ({
-	tag: 'skey',
-	attrs: cipherSuite !== undefined ? { key_cipher_suite: cipherSuite } : {},
-	content: [
-		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
-		{ tag: 'value', attrs: {}, content: key.keyPair.public },
-		{ tag: 'signature', attrs: {}, content: key.signature }
-	]
-})
-exports.xmppSignedPreKey = xmppSignedPreKey
-const xmppPreKey = (pair, id, cipherSuite) => ({
-	tag: 'key',
-	attrs: cipherSuite !== undefined ? { key_cipher_suite: cipherSuite } : {},
-	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 nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user')
-	for (const node of nodes) {
-		;(0, WABinary_1.assertNodeErrorFree)(node)
-	}
-	
-	
-	
-	
-	
-	const chunkSize = 100
-	const chunks = chunk(nodes, chunkSize)
-	for (const nodesChunk of chunks) {
-		for (const node of nodesChunk) {
-			const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey')
-			const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key')
-			const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity')
-			const jid = node.attrs.jid
-			const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4)
-			await repository.injectE2ESession({
-				jid,
-				session: {
-					registrationId: registrationId,
-					identityKey: (0, crypto_1.generateSignalPubKey)(identity),
-					signedPreKey: extractKey(signedKey),
-					preKey: extractKey(key)
-				}
-			})
-		}
-	}
-}
-exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions
-const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
-	const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid)
-	const extracted = []
-	for (const userResult of result) {
-		const { devices, id } = userResult
-		const decoded = (0, WABinary_1.jidDecode)(id),
-			{ user, server } = decoded
-		let { domainType } = decoded
-		const deviceList = devices?.deviceList
-		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) 
-			) {
-				if (isHosted) {
-					domainType =
-						domainType === WABinary_1.WAJIDDomains.LID
-							? WABinary_1.WAJIDDomains.HOSTED_LID
-							: WABinary_1.WAJIDDomains.HOSTED
-				}
-				extracted.push({
-					user,
-					device,
-					domainType,
-					server: (0, WABinary_1.getServerFromDomainType)(server, domainType)
-				})
-			}
-		}
-	}
-	return extracted
-}
-exports.extractDeviceJids = extractDeviceJids
-
-const getNextPreKeys = async ({ creds, keys }, count) => {
-	const { newPreKeys, lastPreKeyId, preKeysRange } = (0, exports.generateOrGetPreKeys)(creds, count)
-	const update = {
-		nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
-		firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
-	}
-	await keys.set({ 'pre-key': newPreKeys })
-	const preKeys = await (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
-	return { update, preKeys }
-}
-exports.getNextPreKeys = getNextPreKeys
-const getNextPreKeysNode = async (state, count) => {
-	const { creds } = state
-	const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count)
-	const node = {
-		tag: 'iq',
-		attrs: {
-			xmlns: 'encrypt',
-			type: 'set',
-			to: WABinary_1.S_WHATSAPP_NET
-		},
-		content: [
-			{ 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)
-		]
-	}
-	return { update, node }
-}
-exports.getNextPreKeysNode = getNextPreKeysNode

package/lib/Utils/stanza-ack.js

@@ -1,67 +0,0 @@
-'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'
-])
-
-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
-		}
-	}
-	
-	if (isCallStanza) {
-		stanza.attrs.type = tag
-	}
-	if (errorCode) {
-		stanza.attrs.error = errorCode.toString()
-	}
-	if (attrs.participant) {
-		stanza.attrs.participant = attrs.participant
-	}
-	if (attrs.recipient) {
-		stanza.attrs.recipient = attrs.recipient
-	}
-	
-	
-	if (attrs.type && !isCallStanza) {
-		stanza.attrs.type = attrs.type
-	}
-	
-	if (tag === 'message' && meId) {
-		stanza.attrs.from = meId
-	}
-	return stanza
-}

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

@@ -1,51 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.emitSyncActionResults = exports.processContactAction = void 0
-const WABinary_1 = require('../WABinary')
-
-const processContactAction = (action, id, logger) => {
-	const results = []
-	if (!id) {
-		logger?.warn(
-			{ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid },
-			'contactAction sync: missing id in index'
-		)
-		return results
-	}
-	const lidJid = action.lidJid
-	const idIsPn = (0, WABinary_1.isPnUser)(id)
-	
-	const phoneNumber = idIsPn ? id : action.pnJid || undefined
-	
-	results.push({
-		event: 'contacts.upsert',
-		data: [
-			{
-				id,
-				name: action.fullName || action.firstName || action.username || undefined,
-				username: action.username || undefined,
-				lid: lidJid || undefined,
-				phoneNumber
-			}
-		]
-	})
-	
-	if (lidJid && (0, WABinary_1.isLidUser)(lidJid) && idIsPn) {
-		results.push({
-			event: 'lid-mapping.update',
-			data: { lid: lidJid, pn: id }
-		})
-	}
-	return results
-}
-exports.processContactAction = processContactAction
-const emitSyncActionResults = (ev, results) => {
-	for (const result of results) {
-		if (result.event === 'contacts.upsert') {
-			ev.emit('contacts.upsert', result.data)
-		} else {
-			ev.emit('lid-mapping.update', result.data)
-		}
-	}
-}
-exports.emitSyncActionResults = emitSyncActionResults