gifted-baileys 1.5.5 → 1.5.7

package/src/Socket/messages-recv.ts

@@ -1,985 +0,0 @@
-
-import { Boom } from '@hapi/boom'
-import { randomBytes } from 'crypto'
-import NodeCache from 'node-cache'
-import { proto } from '../../WAProto'
-import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaults'
-import { MessageReceiptType, MessageRelayOptions, MessageUserReceipt, SocketConfig, WACallEvent, WAMessageKey, WAMessageStatus, WAMessageStubType, WAPatchName } from '../Types'
-import {
-	aesDecryptCTR,
-	aesEncryptGCM,
-	Curve,
-	decodeMediaRetryNode,
-	decryptMessageNode,
-	delay,
-	derivePairingCodeKey,
-	encodeBigEndian,
-	encodeSignedDeviceIdentity,
-	generateMessageIDV2,
-	getCallStatusFromNode,
-	getHistoryMsg,
-	getNextPreKeys,
-	getStatusFromReceiptType, hkdf,
-	unixTimestampSeconds,
-	xmppPreKey,
-	xmppSignedPreKey
-} from '../Utils'
-import { cleanMessage } from '../Utils'
-import { makeMutex } from '../Utils/make-mutex'
-import {
-	areJidsSameUser,
-	BinaryNode,
-	getAllBinaryNodeChildren,
-	getBinaryNodeChild,
-	getBinaryNodeChildBuffer,
-	getBinaryNodeChildren,
-	isJidGroup,
-	isJidUser,
-	jidDecode,
-	jidEncode,
-	jidNormalizedUser,
-	S_WHATSAPP_NET
-} from '../WABinary'
-import { extractGroupMetadata } from './groups'
-import { makeMessagesSocket } from './messages-send'
-
-export const makeMessagesRecvSocket = (config: SocketConfig) => {
-	const {
-		logger,
-		retryRequestDelayMs,
-		maxMsgRetryCount,
-		getMessage,
-		shouldIgnoreJid
-	} = config
-	const sock = makeMessagesSocket(config)
-	const {
-		ev,
-		authState,
-		ws,
-		processingMutex,
-		signalRepository,
-		query,
-		upsertMessage,
-		resyncAppState,
-		onUnexpectedError,
-		assertSessions,
-		sendNode,
-		relayMessage,
-		sendReceipt,
-		uploadPreKeys,
-		getUSyncDevices,
-		createParticipantNodes
-	} = sock
-
-	/** this mutex ensures that each retryRequest will wait for the previous one to finish */
-	const retryMutex = makeMutex()
-
-	const msgRetryCache = config.msgRetryCounterCache || new NodeCache({
-		stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-		useClones: false
-	})
-	const callOfferCache = config.callOfferCache || new NodeCache({
-		stdTTL: DEFAULT_CACHE_TTLS.CALL_OFFER, // 5 mins
-		useClones: false
-	})
-
-	let sendActiveReceipts = false
-
-	const sendMessageAck = async({ tag, attrs, content }: BinaryNode) => {
-		const stanza: BinaryNode = {
-			tag: 'ack',
-			attrs: {
-				id: attrs.id,
-				to: attrs.from,
-				class: tag,
-			}
-		}
-
-		if(!!attrs.participant) {
-			stanza.attrs.participant = attrs.participant
-		}
-
-		if(!!attrs.recipient) {
-			stanza.attrs.recipient = attrs.recipient
-		}
-
-
-    		if(!!attrs.type && (tag !== 'message' || getBinaryNodeChild({ tag, attrs, content }, 'unavailable'))) {
-      			stanza.attrs.type = attrs.type
-    		}
-
-    		if(tag === 'message' && getBinaryNodeChild({ tag, attrs, content }, 'unavailable')) {
-      			stanza.attrs.from = authState.creds.me!.id
-    		}
-
-		logger.debug({ recv: { tag, attrs }, sent: stanza.attrs }, 'sent ack')
-		await sendNode(stanza)
-	}
-
-const offerCall = async(toJid: string, isVideo = false) => {
-		const callId = randomBytes(16).toString('hex').toUpperCase().substring(0, 64)
-
-		const offerContent: BinaryNode[] = []
-		offerContent.push({ tag: 'audio', attrs: { enc: 'opus', rate: '16000' }, content: undefined })
-		offerContent.push({ tag: 'audio', attrs: { enc: 'opus', rate: '8000' }, content: undefined })
-
-		if(isVideo) {
-			offerContent.push({
-				tag: 'video',
-				attrs: { enc: 'vp8', dec: 'vp8', orientation: '0', 'screen_width': '1920', 'screen_height': '1080', 'device_orientation': '0' },
-				content: undefined
-			})
-		}
-
-		offerContent.push({ tag: 'net', attrs: { medium: '3' }, content: undefined })
-		offerContent.push({ tag: 'capability', attrs: { ver: '1' }, content: new Uint8Array([1, 4, 255, 131, 207, 4]) })
-		offerContent.push({ tag: 'encopt', attrs: { keygen: '2' }, content: undefined })
-
-		const encKey = randomBytes(32)
-
-		const devices = (await getUSyncDevices([toJid], true, false)).map(({ user, device }) => jidEncode(user, 's.whatsapp.net', device))
-
-		await assertSessions(devices, true)
-
-		const { nodes: destinations, shouldIncludeDeviceIdentity } = await createParticipantNodes(devices, {
-			call: {
-				callKey: new Uint8Array(encKey)
-			}
-		}, { count: '0' })
-
-		offerContent.push({ tag: 'destination', attrs: {}, content: destinations })
-
-		if(shouldIncludeDeviceIdentity) {
-			offerContent.push({
-				tag: 'device-identity',
-				attrs: {},
-				content: encodeSignedDeviceIdentity(authState.creds.account!, true)
-			})
-		}
-
-		const stanza: BinaryNode = ({
-			tag: 'call',
-			attrs: {
-				id: generateMessageIDV2(),
-				to: toJid,
-			},
-			content: [{
-				tag: 'offer',
-				attrs: {
-					'call-id': callId,
-					'call-creator': authState.creds.me!.id,
-				},
-				content: offerContent,
-			}],
-		})
-		await query(stanza)
-		return {
-			id: callId,
-			to: toJid
-		}
-	}
-    
-	const rejectCall = async(callId: string, callFrom: string) => {
-		const stanza: BinaryNode = ({
-			tag: 'call',
-			attrs: {
-				from: authState.creds.me!.id,
-				to: callFrom,
-			},
-			content: [{
-			    tag: 'reject',
-			    attrs: {
-					'call-id': callId,
-					'call-creator': callFrom,
-					count: '0',
-			    },
-			    content: undefined,
-			}],
-		})
-		await query(stanza)
-	}
-
-	const sendRetryRequest = async(node: BinaryNode, forceIncludeKeys = false) => {
-		const msgId = node.attrs.id
-
-		let retryCount = msgRetryCache.get<number>(msgId) || 0
-		if(retryCount >= maxMsgRetryCount) {
-			logger.debug({ retryCount, msgId }, 'reached retry limit, clearing')
-			msgRetryCache.del(msgId)
-			return
-		}
-
-		retryCount += 1
-		msgRetryCache.set(msgId, retryCount)
-
-		const { account, signedPreKey, signedIdentityKey: identityKey } = authState.creds
-
-		const deviceIdentity = encodeSignedDeviceIdentity(account!, true)
-		await authState.keys.transaction(
-			async() => {
-				const receipt: BinaryNode = {
-					tag: 'receipt',
-					attrs: {
-						id: msgId,
-						type: 'retry',
-						to: node.attrs.from
-					},
-					content: [
-						{
-							tag: 'retry',
-							attrs: {
-								count: retryCount.toString(),
-								id: node.attrs.id,
-								t: node.attrs.t,
-								v: '1'
-							}
-						},
-						{
-							tag: 'registration',
-							attrs: { },
-							content: encodeBigEndian(authState.creds.registrationId)
-						}
-					]
-				}
-
-				if(node.attrs.recipient) {
-					receipt.attrs.recipient = node.attrs.recipient
-				}
-
-				if(node.attrs.participant) {
-					receipt.attrs.participant = node.attrs.participant
-				}
-
-				if(retryCount > 1 || forceIncludeKeys) {
-					const { update, preKeys } = await getNextPreKeys(authState, 1)
-
-					const [keyId] = Object.keys(preKeys)
-					const key = preKeys[+keyId]
-
-					const content = receipt.content! as BinaryNode[]
-					content.push({
-						tag: 'keys',
-						attrs: { },
-						content: [
-							{ tag: 'type', attrs: { }, content: Buffer.from(KEY_BUNDLE_TYPE) },
-							{ tag: 'identity', attrs: { }, content: identityKey.public },
-							xmppPreKey(key, +keyId),
-							xmppSignedPreKey(signedPreKey),
-							{ tag: 'device-identity', attrs: { }, content: deviceIdentity }
-						]
-					})
-
-					ev.emit('creds.update', update)
-				}
-
-				await sendNode(receipt)
-
-				logger.info({ msgAttrs: node.attrs, retryCount }, 'sent retry receipt')
-			}
-		)
-	}
-
-	const handleEncryptNotification = async(node: BinaryNode) => {
-		const from = node.attrs.from
-		if(from === S_WHATSAPP_NET) {
-			const countChild = getBinaryNodeChild(node, 'count')
-			const count = +countChild!.attrs.value
-			const shouldUploadMorePreKeys = count < MIN_PREKEY_COUNT
-
-			logger.debug({ count, shouldUploadMorePreKeys }, 'recv pre-key count')
-			if(shouldUploadMorePreKeys) {
-				await uploadPreKeys()
-			}
-		} else {
-			const identityNode = getBinaryNodeChild(node, 'identity')
-			if(identityNode) {
-				logger.info({ jid: from }, 'identity changed')
-				// not handling right now
-				// signal will override new identity anyway
-			} else {
-				logger.info({ node }, 'unknown encrypt notification')
-			}
-		}
-	}
-
-	const handleGroupNotification = (
-		participant: string,
-		child: BinaryNode,
-		msg: Partial<proto.IWebMessageInfo>
-	) => {
-		switch (child?.tag) {
-		case 'create':
-			const metadata = extractGroupMetadata(child)
-
-			msg.messageStubType = WAMessageStubType.GROUP_CREATE
-			msg.messageStubParameters = [metadata.subject]
-			msg.key = { participant: metadata.owner }
-
-			ev.emit('chats.upsert', [{
-				id: metadata.id,
-				name: metadata.subject,
-				conversationTimestamp: metadata.creation,
-			}])
-			ev.emit('groups.upsert', [{
-				...metadata,
-				author: participant
-			}])
-			break
-		case 'ephemeral':
-		case 'not_ephemeral':
-			msg.message = {
-				protocolMessage: {
-					type: proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
-					ephemeralExpiration: +(child.attrs.expiration || 0)
-				}
-			}
-			break
-		case 'promote':
-		case 'demote':
-		case 'remove':
-		case 'add':
-		case 'leave':
-			const stubType = `GROUP_PARTICIPANT_${child.tag.toUpperCase()}`
-			msg.messageStubType = WAMessageStubType[stubType]
-
-			const participants = getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
-			if(
-				participants.length === 1 &&
-					// if recv. "remove" message and sender removed themselves
-					// mark as left
-					areJidsSameUser(participants[0], participant) &&
-					child.tag === 'remove'
-			) {
-				msg.messageStubType = WAMessageStubType.GROUP_PARTICIPANT_LEAVE
-			}
-
-			msg.messageStubParameters = participants
-			break
-		case 'subject':
-			msg.messageStubType = WAMessageStubType.GROUP_CHANGE_SUBJECT
-			msg.messageStubParameters = [ child.attrs.subject ]
-			break
-		case 'announcement':
-		case 'not_announcement':
-			msg.messageStubType = WAMessageStubType.GROUP_CHANGE_ANNOUNCE
-			msg.messageStubParameters = [ (child.tag === 'announcement') ? 'on' : 'off' ]
-			break
-		case 'locked':
-		case 'unlocked':
-			msg.messageStubType = WAMessageStubType.GROUP_CHANGE_RESTRICT
-			msg.messageStubParameters = [ (child.tag === 'locked') ? 'on' : 'off' ]
-			break
-		case 'invite':
-			msg.messageStubType = WAMessageStubType.GROUP_CHANGE_INVITE_LINK
-			msg.messageStubParameters = [ child.attrs.code ]
-			break
-		case 'member_add_mode':
-			const addMode = child.content
-			if(addMode) {
-				msg.messageStubType = WAMessageStubType.GROUP_MEMBER_ADD_MODE
-				msg.messageStubParameters = [ addMode.toString() ]
-			}
-
-			break
-		case 'membership_approval_mode':
-			const approvalMode: any = getBinaryNodeChild(child, 'group_join')
-			if(approvalMode) {
-				msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE
-				msg.messageStubParameters = [ approvalMode.attrs.state ]
-			}
-
-			break
-		}
-	}
-
-	const processNotification = async(node: BinaryNode) => {
-		const result: Partial<proto.IWebMessageInfo> = { }
-		const [child] = getAllBinaryNodeChildren(node)
-		const nodeType = node.attrs.type
-		const from = jidNormalizedUser(node.attrs.from)
-
-		switch (nodeType) {
-		case 'privacy_token':
-			const tokenList = getBinaryNodeChildren(child, 'token')
-			for(const { attrs, content } of tokenList) {
-				const jid = attrs.jid
-				ev.emit('chats.update', [
-					{
-						id: jid,
-						tcToken: content as Buffer
-					}
-				])
-
-				logger.debug({ jid }, 'got privacy token update')
-			}
-
-			break
-		case 'w:gp2':
-			handleGroupNotification(node.attrs.participant, child, result)
-			break
-		case 'mediaretry':
-			const event = decodeMediaRetryNode(node)
-			ev.emit('messages.media-update', [event])
-			break
-		case 'encrypt':
-			await handleEncryptNotification(node)
-			break
-		case 'newsletter':
-			// TO DO
-			break
-		case 'devices':
-			const devices = getBinaryNodeChildren(child, 'device')
-			if(areJidsSameUser(child.attrs.jid, authState.creds.me!.id)) {
-				const deviceJids = devices.map(d => d.attrs.jid)
-				logger.info({ deviceJids }, 'got my own devices')
-			}
-
-			break
-		case 'server_sync':
-			const update = getBinaryNodeChild(node, 'collection')
-			if(update) {
-				const name = update.attrs.name as WAPatchName
-				await resyncAppState([name], false)
-			}
-
-			break
-		case 'picture':
-			const setPicture = getBinaryNodeChild(node, 'set')
-			const delPicture = getBinaryNodeChild(node, 'delete')
-
-			ev.emit('contacts.update', [{
-				id: jidNormalizedUser(node?.attrs?.jid) || ((setPicture || delPicture)?.attrs?.hash) || '',
-				imgUrl: setPicture ? 'changed' : 'removed'
-			}])
-
-			if(isJidGroup(from)) {
-				const node = setPicture || delPicture
-				result.messageStubType = WAMessageStubType.GROUP_CHANGE_ICON
-
-				if(setPicture) {
-					result.messageStubParameters = [setPicture.attrs.id]
-				}
-
-				result.participant = node?.attrs.author
-				result.key = {
-					...result.key || {},
-					participant: setPicture?.attrs.author
-				}
-			}
-
-			break
-		case 'account_sync':
-			if(child.tag === 'disappearing_mode') {
-				const newDuration = +child.attrs.duration
-				const timestamp = +child.attrs.t
-
-				logger.info({ newDuration }, 'updated account disappearing mode')
-
-				ev.emit('creds.update', {
-					accountSettings: {
-						...authState.creds.accountSettings,
-						defaultDisappearingMode: {
-							ephemeralExpiration: newDuration,
-							ephemeralSettingTimestamp: timestamp,
-						},
-					}
-				})
-			} else if(child.tag === 'blocklist') {
-				const blocklists = getBinaryNodeChildren(child, 'item')
-
-				for(const { attrs } of blocklists) {
-					const blocklist = [attrs.jid]
-					const type = (attrs.action === 'block') ? 'add' : 'remove'
-					ev.emit('blocklist.update', { blocklist, type })
-				}
-			}
-
-			break
-		case 'link_code_companion_reg':
-			const linkCodeCompanionReg = getBinaryNodeChild(node, 'link_code_companion_reg')
-			const ref = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_ref'))
-			const primaryIdentityPublicKey = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'primary_identity_pub'))
-			const primaryEphemeralPublicKeyWrapped = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_wrapped_primary_ephemeral_pub'))
-			const codePairingPublicKey = decipherLinkPublicKey(primaryEphemeralPublicKeyWrapped)
-			const companionSharedKey = Curve.sharedKey(authState.creds.pairingEphemeralKeyPair.private, codePairingPublicKey)
-			const random = randomBytes(32)
-			const linkCodeSalt = randomBytes(32)
-			const linkCodePairingExpanded = hkdf(companionSharedKey, 32, {
-				salt: linkCodeSalt,
-				info: 'link_code_pairing_key_bundle_encryption_key'
-			})
-			const encryptPayload = Buffer.concat([Buffer.from(authState.creds.signedIdentityKey.public), primaryIdentityPublicKey, random])
-			const encryptIv = randomBytes(12)
-			const encrypted = aesEncryptGCM(encryptPayload, linkCodePairingExpanded, encryptIv, Buffer.alloc(0))
-			const encryptedPayload = Buffer.concat([linkCodeSalt, encryptIv, encrypted])
-			const identitySharedKey = Curve.sharedKey(authState.creds.signedIdentityKey.private, primaryIdentityPublicKey)
-			const identityPayload = Buffer.concat([companionSharedKey, identitySharedKey, random])
-			authState.creds.advSecretKey = hkdf(identityPayload, 32, { info: 'adv_secret' }).toString('base64')
-			await query({
-				tag: 'iq',
-				attrs: {
-					to: S_WHATSAPP_NET,
-					type: 'set',
-					id: sock.generateMessageTag(),
-					xmlns: 'md'
-				},
-				content: [
-					{
-						tag: 'link_code_companion_reg',
-						attrs: {
-							jid: authState.creds.me!.id,
-							stage: 'companion_finish',
-						},
-						content: [
-							{
-								tag: 'link_code_pairing_wrapped_key_bundle',
-								attrs: {},
-								content: encryptedPayload
-							},
-							{
-								tag: 'companion_identity_public',
-								attrs: {},
-								content: authState.creds.signedIdentityKey.public
-							},
-							{
-								tag: 'link_code_pairing_ref',
-								attrs: {},
-								content: ref
-							}
-						]
-					}
-				]
-			})
-			authState.creds.registered = true
-			ev.emit('creds.update', authState.creds)
-		}
-
-		if(Object.keys(result).length) {
-			return result
-		}
-	}
-
-	function decipherLinkPublicKey(data: Uint8Array | Buffer) {
-		const buffer = toRequiredBuffer(data)
-		const salt = buffer.slice(0, 32)
-		const secretKey = derivePairingCodeKey(authState.creds.pairingCode!, salt)
-		const iv = buffer.slice(32, 48)
-		const payload = buffer.slice(48, 80)
-		return aesDecryptCTR(payload, secretKey, iv)
-	}
-
-	function toRequiredBuffer(data: Uint8Array | Buffer | undefined) {
-		if(data === undefined) {
-			throw new Boom('Invalid buffer', { statusCode: 400 })
-		}
-
-		return data instanceof Buffer ? data : Buffer.from(data)
-	}
-
-	const willSendMessageAgain = (id: string, participant: string) => {
-		const key = `${id}:${participant}`
-		const retryCount = msgRetryCache.get<number>(key) || 0
-		return retryCount < maxMsgRetryCount
-	}
-
-	const updateSendMessageAgainCount = (id: string, participant: string) => {
-		const key = `${id}:${participant}`
-		const newValue = (msgRetryCache.get<number>(key) || 0) + 1
-		msgRetryCache.set(key, newValue)
-	}
-
-	const sendMessagesAgain = async(
-		key: proto.IMessageKey,
-		ids: string[],
-		retryNode: BinaryNode
-	) => {
-		const msgs = await Promise.all(ids.map(id => getMessage({ ...key, id })))
-		const remoteJid = key.remoteJid!
-		const participant = key.participant || remoteJid
-		// if it's the primary jid sending the request
-		// just re-send the message to everyone
-		// prevents the first message decryption failure
-		const sendToAll = !jidDecode(participant)?.device
-		await assertSessions([participant], true)
-
-		if(isJidGroup(remoteJid)) {
-			await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } })
-		}
-
-		logger.debug({ participant, sendToAll }, 'forced new session for retry recp')
-
-		for(let i = 0; i < msgs.length;i++) {
-			const msg = msgs[i]
-			if(msg) {
-				updateSendMessageAgainCount(ids[i], participant)
-				const msgRelayOpts: MessageRelayOptions = { messageId: ids[i] }
-
-				if(sendToAll) {
-					msgRelayOpts.useUserDevicesCache = false
-				} else {
-					msgRelayOpts.participant = {
-						jid: participant,
-						count: +retryNode.attrs.count
-					}
-				}
-
-				await relayMessage(key.remoteJid!, msg, msgRelayOpts)
-			} else {
-				logger.debug({ jid: key.remoteJid, id: ids[i] }, 'recv retry request, but message not available')
-			}
-		}
-	}
-
-	const handleReceipt = async(node: BinaryNode) => {
-		const { attrs, content } = node
-		const isLid = attrs.from.includes('lid')
-		const isNodeFromMe = areJidsSameUser(attrs.participant || attrs.from, isLid ? authState.creds.me?.lid : authState.creds.me?.id)
-		const remoteJid = !isNodeFromMe || isJidGroup(attrs.from) ? attrs.from : attrs.recipient
-		const fromMe = !attrs.recipient || (attrs.type === 'retry' && isNodeFromMe)
-
-		const key: proto.IMessageKey = {
-			remoteJid,
-			id: '',
-			fromMe,
-			participant: attrs.participant
-		}
-
-		if(shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
-			logger.debug({ remoteJid }, 'ignoring receipt from jid')
-			await sendMessageAck(node)
-			return
-		}
-
-		const ids = [attrs.id]
-		if(Array.isArray(content)) {
-			const items = getBinaryNodeChildren(content[0], 'item')
-			ids.push(...items.map(i => i.attrs.id))
-		}
-
-		await Promise.all([
-			processingMutex.mutex(
-				async() => {
-					const status = getStatusFromReceiptType(attrs.type)
-					if(
-						typeof status !== 'undefined' &&
-						(
-							// basically, we only want to know when a message from us has been delivered to/read by the other person
-							// or another device of ours has read some messages
-							status > proto.WebMessageInfo.Status.DELIVERY_ACK ||
-							!isNodeFromMe
-						)
-					) {
-						if(isJidGroup(remoteJid)) {
-							if(attrs.participant) {
-								const updateKey: keyof MessageUserReceipt = status === proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp'
-								ev.emit(
-									'message-receipt.update',
-									ids.map(id => ({
-										key: { ...key, id },
-										receipt: {
-											userJid: jidNormalizedUser(attrs.participant),
-											[updateKey]: +attrs.t
-										}
-									}))
-								)
-							}
-						} else {
-							ev.emit(
-								'messages.update',
-								ids.map(id => ({
-									key: { ...key, id },
-									update: { status }
-								}))
-							)
-						}
-					}
-
-					if(attrs.type === 'retry') {
-						// correctly set who is asking for the retry
-						key.participant = key.participant || attrs.from
-						const retryNode = getBinaryNodeChild(node, 'retry')
-						if(willSendMessageAgain(ids[0], key.participant)) {
-							if(key.fromMe) {
-								try {
-									logger.debug({ attrs, key }, 'recv retry request')
-									await sendMessagesAgain(key, ids, retryNode!)
-								} catch(error) {
-									logger.error({ key, ids, trace: error.stack }, 'error in sending message again')
-								}
-							} else {
-								logger.info({ attrs, key }, 'recv retry for not fromMe message')
-							}
-						} else {
-							logger.info({ attrs, key }, 'will not send message again, as sent too many times')
-						}
-					}
-				}
-			),
-			sendMessageAck(node)
-		])
-	}
-
-	const handleNotification = async(node: BinaryNode) => {
-		const remoteJid = node.attrs.from
-		if(shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
-			logger.debug({ remoteJid, id: node.attrs.id }, 'ignored notification')
-			await sendMessageAck(node)
-			return
-		}
-
-		await Promise.all([
-			processingMutex.mutex(
-				async() => {
-					const msg = await processNotification(node)
-					if(msg) {
-						const fromMe = areJidsSameUser(node.attrs.participant || remoteJid, authState.creds.me!.id)
-						msg.key = {
-							remoteJid,
-							fromMe,
-							participant: node.attrs.participant,
-							id: node.attrs.id,
-							...(msg.key || {})
-						}
-						msg.participant ??= node.attrs.participant
-						msg.messageTimestamp = +node.attrs.t
-
-						const fullMsg = proto.WebMessageInfo.fromObject(msg)
-						await upsertMessage(fullMsg, 'append')
-					}
-				}
-			),
-			sendMessageAck(node)
-		])
-	}
-
-	const handleMessage = async(node: BinaryNode) => {
-		if(shouldIgnoreJid(node.attrs.from!) && node.attrs.from! !== '@s.whatsapp.net') {
-			logger.debug({ key: node.attrs.key }, 'ignored message')
-			await sendMessageAck(node)
-			return
-		}
-
-		const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(
-			node,
-			authState.creds.me!.id,
-			authState.creds.me!.lid || '',
-			signalRepository,
-			logger,
-		)
-
-		if(msg.message?.protocolMessage?.type === proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER) {
-			if(node.attrs.sender_pn) {
-				ev.emit('chats.phoneNumberShare', { lid: node.attrs.from, jid: node.attrs.sender_pn })
-			}
-		}
-
-		await Promise.all([
-			processingMutex.mutex(
-				async() => {
-					await decrypt()
-					// message failed to decrypt
-					if(msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT) {
-						retryMutex.mutex(
-							async() => {
-								if(ws.isOpen) {
-									const encNode = getBinaryNodeChild(node, 'enc')
-									await sendRetryRequest(node, !encNode)
-									if(retryRequestDelayMs) {
-										await delay(retryRequestDelayMs)
-									}
-								} else {
-									logger.debug({ node }, 'connection closed, ignoring retry req')
-								}
-							}
-						)
-					} else {
-						// no type in the receipt => message delivered
-						let type: MessageReceiptType = undefined
-						let participant = msg.key.participant
-						if(category === 'peer') { // special peer message
-							type = 'peer_msg'
-						} else if(msg.key.fromMe) { // message was sent by us from a different device
-							type = 'sender'
-							// need to specially handle this case
-							if(isJidUser(msg.key.remoteJid!)) {
-								participant = author
-							}
-						} else if(!sendActiveReceipts) {
-							type = 'inactive'
-						}
-
-						await sendReceipt(msg.key.remoteJid!, participant!, [msg.key.id!], type)
-
-						// send ack for history message
-						const isAnyHistoryMsg = getHistoryMsg(msg.message!)
-						if(isAnyHistoryMsg) {
-							const jid = jidNormalizedUser(msg.key.remoteJid!)
-							await sendReceipt(jid, undefined, [msg.key.id!], 'hist_sync')
-						}
-					}
-
-					cleanMessage(msg, authState.creds.me!.id)
-
-					await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify')
-				}
-			),
-			sendMessageAck(node)
-		])
-	}
-
-	const handleCall = async(node: BinaryNode) => {
-		const { attrs } = node
-		const [infoChild] = getAllBinaryNodeChildren(node)
-		const callId = infoChild.attrs['call-id']
-		const from = infoChild.attrs.from || infoChild.attrs['call-creator']
-		const status = getCallStatusFromNode(infoChild)
-		const call: WACallEvent = {
-			chatId: attrs.from,
-			from,
-			id: callId,
-			date: new Date(+attrs.t * 1000),
-			offline: !!attrs.offline,
-			status,
-		}
-
-		if(status === 'offer') {
-			call.isVideo = !!getBinaryNodeChild(infoChild, 'video')
-			call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid']
-			call.groupJid = infoChild.attrs['group-jid']
-			callOfferCache.set(call.id, call)
-		}
-
-		const existingCall = callOfferCache.get<WACallEvent>(call.id)
-
-		// use existing call info to populate this event
-		if(existingCall) {
-			call.isVideo = existingCall.isVideo
-			call.isGroup = existingCall.isGroup
-		}
-
-		// delete data once call has ended
-		if(status === 'reject' || status === 'accept' || status === 'timeout') {
-			callOfferCache.del(call.id)
-		}
-
-		ev.emit('call', [call])
-
-		await sendMessageAck(node)
-	}
-
-	const handleBadAck = async({ attrs }: BinaryNode) => {
-		const key: WAMessageKey = { remoteJid: attrs.from, fromMe: true, id: attrs.id }
-		// current hypothesis is that if pash is sent in the ack
-		// it means -- the message hasn't reached all devices yet
-		// we'll retry sending the message here
-		if(attrs.phash) {
-			logger.info({ attrs }, 'received phash in ack, resending message...')
-			const msg = await getMessage(key)
-			if(msg) {
-				await relayMessage(key.remoteJid!, msg, { messageId: key.id!, useUserDevicesCache: false })
-			} else {
-				logger.warn({ attrs }, 'could not send message again, as it was not found')
-			}
-		}
-
-		// error in acknowledgement,
-		// device could not display the message
-		if(attrs.error) {
-			logger.warn({ attrs }, 'received error in ack')
-			ev.emit(
-				'messages.update',
-				[
-					{
-						key,
-						update: {
-							status: WAMessageStatus.ERROR,
-							messageStubParameters: [
-								attrs.error
-							]
-						}
-					}
-				]
-			)
-		}
-	}
-
-	/// processes a node with the given function
-	/// and adds the task to the existing buffer if we're buffering events
-	const processNodeWithBuffer = async<T>(
-		node: BinaryNode,
-		identifier: string,
-		exec: (node: BinaryNode) => Promise<T>
-	) => {
-		ev.buffer()
-		await execTask()
-		ev.flush()
-
-		function execTask() {
-			return exec(node)
-				.catch(err => onUnexpectedError(err, identifier))
-		}
-	}
-
-	// recv a message
-	ws.on('CB:message', (node: BinaryNode) => {
-		processNodeWithBuffer(node, 'processing message', handleMessage)
-	})
-
-	ws.on('CB:call', async(node: BinaryNode) => {
-		processNodeWithBuffer(node, 'handling call', handleCall)
-	})
-
-	ws.on('CB:receipt', node => {
-		processNodeWithBuffer(node, 'handling receipt', handleReceipt)
-	})
-
-	ws.on('CB:notification', async(node: BinaryNode) => {
-		processNodeWithBuffer(node, 'handling notification', handleNotification)
-	})
-
-	ws.on('CB:ack,class:message', (node: BinaryNode) => {
-		handleBadAck(node)
-			.catch(error => onUnexpectedError(error, 'handling bad ack'))
-	})
-
-	ev.on('call', ([ call ]) => {
-		// missed call + group call notification message generation
-		if(call.status === 'timeout' || (call.status === 'offer' && call.isGroup)) {
-			const msg: proto.IWebMessageInfo = {
-				key: {
-					remoteJid: call.chatId,
-					id: call.id,
-					fromMe: false
-				},
-				messageTimestamp: unixTimestampSeconds(call.date),
-			}
-			if(call.status === 'timeout') {
-				if(call.isGroup) {
-					msg.messageStubType = call.isVideo ? WAMessageStubType.CALL_MISSED_GROUP_VIDEO : WAMessageStubType.CALL_MISSED_GROUP_VOICE
-				} else {
-					msg.messageStubType = call.isVideo ? WAMessageStubType.CALL_MISSED_VIDEO : WAMessageStubType.CALL_MISSED_VOICE
-				}
-			} else {
-				msg.message = { call: { callKey: Buffer.from(call.id) } }
-			}
-
-			const protoMsg = proto.WebMessageInfo.fromObject(msg)
-			upsertMessage(protoMsg, call.offline ? 'append' : 'notify')
-		}
-	})
-
-	ev.on('connection.update', ({ isOnline }) => {
-		if(typeof isOnline !== 'undefined') {
-			sendActiveReceipts = isOnline
-			logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`)
-		}
-	})
-
-	return {
-		...sock,
-		sendMessageAck,
-		sendRetryRequest,
-		offerCall,
-		rejectCall
-	}
-}