gifted-baileys 1.5.6 → 1.5.7

package/src/Socket/newsletter.ts

@@ -1,282 +0,0 @@
-import { NewsletterFetchedUpdate, NewsletterMetadata, NewsletterReaction, NewsletterReactionMode, NewsletterViewRole, QueryIds, SocketConfig, WAMediaUpload, XWAPaths } from '../Types'
-import { decryptMessageNode, generateMessageID, generateProfilePicture } from '../Utils'
-import { BinaryNode, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildren, S_WHATSAPP_NET } from '../WABinary'
-import { makeGroupsSocket } from './groups'
-
-export const makeNewsletterSocket = (config: SocketConfig) => {
-	const sock = makeGroupsSocket(config)
-	const { authState, signalRepository, query, generateMessageTag } = sock
-
-	const encoder = new TextEncoder()
-
-	const newsletterQuery = async(jid: string, type: 'get' | 'set', content: BinaryNode[]) => (
-		query({
-			tag: 'iq',
-			attrs: {
-				id: generateMessageTag(),
-				type,
-				xmlns: 'newsletter',
-				to: jid,
-			},
-			content
-		})
-	)
-
-	const newsletterWMexQuery = async(jid: string | undefined, queryId: QueryIds, content?: object) => (
-		query({
-			tag: 'iq',
-			attrs: {
-				id: generateMessageTag(),
-				type: 'get',
-				xmlns: 'w:mex',
-				to: S_WHATSAPP_NET,
-			},
-			content: [
-				{
-					tag: 'query',
-					attrs: { 'query_id': queryId },
-					content: encoder.encode(
-						JSON.stringify({
-							variables: {
-								'newsletter_id': jid,
-								...content
-							}
-						})
-					)
-				}
-			]
-		})
-	)
-
-	const parseFetchedUpdates = async(node: BinaryNode, type: 'messages' | 'updates') => {
-		let child
-
-		if(type === 'messages') {
-			child = getBinaryNodeChild(node, 'messages')
-		} else {
-			const parent = getBinaryNodeChild(node, 'message_updates')
-			child = getBinaryNodeChild(parent, 'messages')
-		}
-
-		return await Promise.all(getAllBinaryNodeChildren(child).map(async messageNode => {
-			messageNode.attrs.from = child?.attrs.jid as string
-
-			const views = parseInt(getBinaryNodeChild(messageNode, 'views_count')?.attrs?.count || '0')
-			const reactionNode = getBinaryNodeChild(messageNode, 'reactions')
-			const reactions = getBinaryNodeChildren(reactionNode, 'reaction')
-				.map(({ attrs }) => ({ count: +attrs.count, code: attrs.code } as NewsletterReaction))
-
-			const data: NewsletterFetchedUpdate = {
-				'server_id': messageNode.attrs.server_id,
-				views,
-				reactions
-			}
-
-			if(type === 'messages') {
-				const { fullMessage: message, decrypt } = await decryptMessageNode(
-					messageNode,
-                    authState.creds.me!.id,
-                    authState.creds.me!.lid || '',
-                    signalRepository,
-                    config.logger
-				)
-
-				await decrypt()
-
-				data.message = message
-			}
-
-			return data
-		}))
-	}
-
-	return {
-		...sock,
-		subscribeNewsletterUpdates: async(jid: string) => {
-			const result = await newsletterQuery(jid, 'set', [{ tag: 'live_updates', attrs: {}, content: [] }])
-
-			return getBinaryNodeChild(result, 'live_updates')?.attrs as {duration: string}
-		},
-
-		newsletterReactionMode: async(jid: string, mode: NewsletterReactionMode) => {
-			await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-				updates: { settings: { 'reaction_codes': { value: mode } } }
-			})
-		},
-
-		newsletterUpdateDescription: async(jid: string, description?: string) => {
-			await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-				updates: { description: description || '', settings: null }
-			})
-		},
-
-		newsletterUpdateName: async(jid: string, name: string) => {
-			await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-				updates: { name, settings: null }
-			})
-		},
-
-		newsletterUpdatePicture: async(jid: string, content: WAMediaUpload) => {
-			const { img } = await generateProfilePicture(content)
-
-			await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-				updates: { picture: img.toString('base64'), settings: null }
-			})
-		},
-
-		newsletterRemovePicture: async(jid: string) => {
-			await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-				updates: { picture: '', settings: null }
-			})
-		},
-
-        newsletterUnfollow: async(jid: string) => {
-            await newsletterWMexQuery(jid, QueryIds.UNFOLLOW)
-        },
-
-        newsletterFollow: async(jid: string) => {
-            await newsletterWMexQuery(jid, QueryIds.FOLLOW)
-        },
-
-        newsletterUnmute: async(jid: string) => {
-            await newsletterWMexQuery(jid, QueryIds.UNMUTE)
-        },
-
-        newsletterMute: async(jid: string) => {
-            await newsletterWMexQuery(jid, QueryIds.MUTE)
-        },
-
-		newsletterAction: async(jid: string, type: 'follow' | 'unfollow' | 'mute' | 'unmute') => {
-			await newsletterWMexQuery(jid, type.toUpperCase() as QueryIds)
-		},
-
-		newsletterCreate: async(name: string, description: string, reaction_codes: string) => {
-			//TODO: Implement TOS system wide for Meta AI, communities, and here etc.
-			/**tos query */
-			await query({
-				tag: 'iq',
-				attrs: {
-					to: S_WHATSAPP_NET,
-					xmlns: 'tos',
-					id: generateMessageTag(),
-					type: 'set'
-				},
-				content: [
-					{
-						tag: 'notice',
-						attrs: {
-							id: '20601218',
-							stage: '5'
-						},
-						content: []
-					}
-				]
-			})
-			const result = await newsletterWMexQuery(undefined, QueryIds.CREATE, {
-				input: { name, description, settings: { 'reaction_codes': { value: reaction_codes.toUpperCase() } } }
-			})
-
-			return extractNewsletterMetadata(result, true)
-		},
-
-		newsletterMetadata: async(type: 'invite' | 'jid', key: string, role?: NewsletterViewRole) => {
-			const result = await newsletterWMexQuery(undefined, QueryIds.METADATA, {
-				input: {
-					key,
-					type: type.toUpperCase(),
-					'view_role': role || 'GUEST'
-				},
-				'fetch_viewer_metadata': true,
-				'fetch_full_image': true,
-				'fetch_creation_time': true
-			})
-
-			return extractNewsletterMetadata(result)
-		},
-
-		newsletterAdminCount: async(jid: string) => {
-			const result = await newsletterWMexQuery(jid, QueryIds.ADMIN_COUNT)
-
-			const buff = getBinaryNodeChild(result, 'result')?.content?.toString()
-
-			return JSON.parse(buff!).data[XWAPaths.ADMIN_COUNT].admin_count as number
-		},
-
-		/**user is Lid, not Jid */
-		newsletterChangeOwner: async(jid: string, user: string) => {
-			await newsletterWMexQuery(jid, QueryIds.CHANGE_OWNER, {
-				'user_id': user
-			})
-		},
-
-		/**user is Lid, not Jid */
-		newsletterDemote: async(jid: string, user: string) => {
-			await newsletterWMexQuery(jid, QueryIds.DEMOTE, {
-				'user_id': user
-			})
-		},
-
-		newsletterDelete: async(jid: string) => {
-			await newsletterWMexQuery(jid, QueryIds.DELETE)
-		},
-
-		/**if code wasn't passed, the reaction will be removed (if is reacted) */
-		newsletterReactMessage: async(jid: string, serverId: string, code?: string) => {
-			await query({
-				tag: 'message',
-				attrs: { to: jid, ...(!code ? { edit: '7' } : {}), type: 'reaction', 'server_id': serverId, id: generateMessageID() },
-				content: [{
-					tag: 'reaction',
-					attrs: code ? { code } : {}
-				}]
-			})
-		},
-
-		newsletterFetchMessages: async(type: 'invite' | 'jid', key: string, count: number, after?: number) => {
-			const result = await newsletterQuery(S_WHATSAPP_NET, 'get', [
-				{
-					tag: 'messages',
-					attrs: { type, ...(type === 'invite' ? { key } : { jid: key }), count: count.toString(), after: after?.toString() || '100' }
-				}
-			])
-
-			return await parseFetchedUpdates(result, 'messages')
-		},
-
-		newsletterFetchUpdates: async(jid: string, count: number, after?: number, since?: number) => {
-			const result = await newsletterQuery(jid, 'get', [
-				{
-					tag: 'message_updates',
-					attrs: { count: count.toString(), after: after?.toString() || '100', since: since?.toString() || '0' }
-				}
-			])
-
-			return await parseFetchedUpdates(result, 'updates')
-		}
-	}
-}
-
-export const extractNewsletterMetadata = (node: BinaryNode, isCreate?: boolean) => {
-	const result = getBinaryNodeChild(node, 'result')?.content?.toString()
-	const metadataPath = JSON.parse(result!).data[isCreate ? XWAPaths.CREATE : XWAPaths.NEWSLETTER]
-
-	const metadata: NewsletterMetadata = {
-		id: metadataPath.id,
-		state: metadataPath.state.type,
-		'creation_time': +metadataPath.thread_metadata.creation_time,
-		name: metadataPath.thread_metadata.name.text,
-		nameTime: +metadataPath.thread_metadata.name.update_time,
-		description: metadataPath.thread_metadata.description.text,
-		descriptionTime: +metadataPath.thread_metadata.description.update_time,
-		invite: metadataPath.thread_metadata.invite,
-		handle: metadataPath.thread_metadata.handle,
-		picture: metadataPath.thread_metadata.picture?.direct_path || null,
-        preview: metadataPath.thread_metadata.preview?.direct_path || null,
-		'reaction_codes': metadataPath.thread_metadata?.settings?.reaction_codes?.value,
-		subscribers: +metadataPath.thread_metadata.subscribers_count,
-		verification: metadataPath.thread_metadata.verification,
-		'viewer_metadata': metadataPath.viewer_metadata
-	}
-
-	return metadata
-}

package/src/Socket/registration.ts

@@ -1,250 +0,0 @@
-/* eslint-disable camelcase */
-import axios, { AxiosRequestConfig } from 'axios'
-import { MOBILE_REGISTRATION_ENDPOINT, MOBILE_TOKEN, MOBILE_USERAGENT, REGISTRATION_PUBLIC_KEY } from '../Defaults'
-import { KeyPair, SignedKeyPair, SocketConfig } from '../Types'
-import { aesEncryptGCM, Curve, md5 } from '../Utils/crypto'
-import { jidEncode } from '../WABinary'
-import { makeBusinessSocket } from './business'
-
-function urlencode(str: string) {
-	return str.replace(/-/g, '%2d').replace(/_/g, '%5f').replace(/~/g, '%7e')
-}
-
-const validRegistrationOptions = (config: RegistrationOptions) => config?.phoneNumberCountryCode &&
-	config.phoneNumberNationalNumber &&
-	config.phoneNumberMobileCountryCode
-
-export const makeRegistrationSocket = (config: SocketConfig) => {
-	const sock = makeBusinessSocket(config)
-
-	const register = async(code: string) => {
-		if(!validRegistrationOptions(config.auth.creds.registration)) {
-			throw new Error('please specify the registration options')
-		}
-
-		const result = await mobileRegister({ ...sock.authState.creds, ...sock.authState.creds.registration as RegistrationOptions, code }, config.options)
-
-		sock.authState.creds.me = {
-			id: jidEncode(result.login!, 's.whatsapp.net'),
-			name: '~'
-		}
-
-		sock.authState.creds.registered = true
-		sock.ev.emit('creds.update', sock.authState.creds)
-
-		return result
-	}
-
-	const requestRegistrationCode = async(registrationOptions?: RegistrationOptions) => {
-		registrationOptions = registrationOptions || config.auth.creds.registration
-		if(!validRegistrationOptions(registrationOptions)) {
-			throw new Error('Invalid registration options')
-		}
-
-		sock.authState.creds.registration = registrationOptions
-
-		sock.ev.emit('creds.update', sock.authState.creds)
-
-		return mobileRegisterCode({ ...config.auth.creds, ...registrationOptions }, config.options)
-	}
-
-	return {
-		...sock,
-		register,
-		requestRegistrationCode,
-	}
-}
-
-// Backup_token: Base64.getEncoder().encodeToString(Arrays.copyOfRange(Base64.getDecoder().decode(UUID.randomUUID().toString().replace('-','')),0,15))
-
-export interface RegistrationData {
-	registrationId: number
-	signedPreKey: SignedKeyPair
-	noiseKey: KeyPair
-	signedIdentityKey: KeyPair
-	identityId: Buffer
-	phoneId: string
-	deviceId: string
-	backupToken: Buffer
-}
-
-export interface RegistrationOptions {
-	/** your phone number */
-	phoneNumber?: string
-	/** the country code of your phone number */
-	phoneNumberCountryCode: string
-	/** your phone number without country code */
-	phoneNumberNationalNumber: string
-	/** the country code of your mobile network
-	 * @see {@link https://de.wikipedia.org/wiki/Mobile_Country_Code}
-	 */
-	phoneNumberMobileCountryCode: string
-	/** the network code of your mobile network
-	 * @see {@link https://de.wikipedia.org/wiki/Mobile_Network_Code}
-	 */
-	phoneNumberMobileNetworkCode: string
-	/**
-	 * How to send the one time code
-	 */
-	method?: 'sms' | 'voice' | 'captcha'
-	/**
-	 * The captcha code if it was requested
-	 */
-	captcha?: string
-}
-
-export type RegistrationParams = RegistrationData & RegistrationOptions
-
-function convertBufferToUrlHex(buffer: Buffer) {
-	var id = ''
-
-	buffer.forEach((x) => {
-		// encode random identity_id buffer as percentage url encoding
-		id += `%${x.toString(16).padStart(2, '0').toLowerCase()}`
-	})
-
-	return id
-}
-
-export function registrationParams(params: RegistrationParams) {
-	const e_regid = Buffer.alloc(4)
-	e_regid.writeInt32BE(params.registrationId)
-
-	const e_skey_id = Buffer.alloc(3)
-	e_skey_id.writeInt16BE(params.signedPreKey.keyId)
-
-	params.phoneNumberCountryCode = params.phoneNumberCountryCode.replace('+', '').trim()
-	params.phoneNumberNationalNumber = params.phoneNumberNationalNumber.replace(/[/-\s)(]/g, '').trim()
-
-	return {
-		cc: params.phoneNumberCountryCode,
-		in: params.phoneNumberNationalNumber,
-		Rc: '0',
-		lg: 'en',
-		lc: 'GB',
-		mistyped: '6',
-		authkey: Buffer.from(params.noiseKey.public).toString('base64url'),
-		e_regid: e_regid.toString('base64url'),
-		e_keytype: 'BQ',
-		e_ident: Buffer.from(params.signedIdentityKey.public).toString('base64url'),
-		// e_skey_id: e_skey_id.toString('base64url'),
-		e_skey_id: 'AAAA',
-		e_skey_val: Buffer.from(params.signedPreKey.keyPair.public).toString('base64url'),
-		e_skey_sig: Buffer.from(params.signedPreKey.signature).toString('base64url'),
-		fdid: params.phoneId,
-		network_ratio_type: '1',
-		expid: params.deviceId,
-		simnum: '1',
-		hasinrc: '1',
-		pid: Math.floor(Math.random() * 1000).toString(),
-		id: convertBufferToUrlHex(params.identityId),
-		backup_token: convertBufferToUrlHex(params.backupToken),
-		token: md5(Buffer.concat([MOBILE_TOKEN, Buffer.from(params.phoneNumberNationalNumber)])).toString('hex'),
-		fraud_checkpoint_code: params.captcha,
-	}
-}
-
-/**
- * Requests a registration code for the given phone number.
- */
-export function mobileRegisterCode(params: RegistrationParams, fetchOptions?: AxiosRequestConfig) {
-	return mobileRegisterFetch('/code', {
-		params: {
-			...registrationParams(params),
-			mcc: `${params.phoneNumberMobileCountryCode}`.padStart(3, '0'),
-			mnc: `${params.phoneNumberMobileNetworkCode || '001'}`.padStart(3, '0'),
-			sim_mcc: '000',
-			sim_mnc: '000',
-			method: params?.method || 'sms',
-			reason: '',
-			hasav: '1'
-		},
-		...fetchOptions,
-	})
-}
-
-export function mobileRegisterExists(params: RegistrationParams, fetchOptions?: AxiosRequestConfig) {
-	return mobileRegisterFetch('/exist', {
-		params: registrationParams(params),
-		...fetchOptions
-	})
-}
-
-/**
- * Registers the phone number on whatsapp with the received OTP code.
- */
-export async function mobileRegister(params: RegistrationParams & { code: string }, fetchOptions?: AxiosRequestConfig) {
-	//const result = await mobileRegisterFetch(`/reg_onboard_abprop?cc=${params.phoneNumberCountryCode}&in=${params.phoneNumberNationalNumber}&rc=0`)
-
-	return mobileRegisterFetch('/register', {
-		params: { ...registrationParams(params), code: params.code.replace('-', '') },
-		...fetchOptions,
-	})
-}
-
-/**
- * Encrypts the given string as AEAD aes-256-gcm with the public whatsapp key and a random keypair.
- */
-export function mobileRegisterEncrypt(data: string) {
-	const keypair = Curve.generateKeyPair()
-	const key = Curve.sharedKey(keypair.private, REGISTRATION_PUBLIC_KEY)
-
-	const buffer = aesEncryptGCM(Buffer.from(data), new Uint8Array(key), Buffer.alloc(12), Buffer.alloc(0))
-
-	return Buffer.concat([Buffer.from(keypair.public), buffer]).toString('base64url')
-}
-
-export async function mobileRegisterFetch(path: string, opts: AxiosRequestConfig = {}) {
-	let url = `${MOBILE_REGISTRATION_ENDPOINT}${path}`
-
-	if(opts.params) {
-		const parameter = [] as string[]
-
-		for(const param in opts.params) {
-			if(opts.params[param] !== null && opts.params[param] !== undefined) {
-				parameter.push(param + '=' + urlencode(opts.params[param]))
-			}
-		}
-
-		url += `?${parameter.join('&')}`
-		delete opts.params
-	}
-
-	if(!opts.headers) {
-		opts.headers = {}
-	}
-
-	opts.headers['User-Agent'] = MOBILE_USERAGENT
-
-	const response = await axios(url, opts)
-
-	var json = response.data
-
-	if(response.status > 300 || json.reason) {
-		throw json
-	}
-
-	if(json.status && !['ok', 'sent'].includes(json.status)) {
-		throw json
-	}
-
-	return json as ExistsResponse
-}
-
-
-export interface ExistsResponse {
-	status: 'fail' | 'sent'
-	voice_length?: number
-	voice_wait?: number
-	sms_length?: number
-	sms_wait?: number
-	reason?: 'incorrect' | 'missing_param' | 'code_checkpoint'
-	login?: string
-	flash_type?: number
-	ab_hash?: string
-	ab_key?: string
-	exp_cfg?: string
-	lid?: string
-	image_blob?: string
-	audio_blob?: string
-}