gifted-baileys 1.5.0 → 1.5.5

package/src/Utils/process-message.ts

@@ -0,0 +1,414 @@
+import { AxiosRequestConfig } from 'axios'
+import type { Logger } from 'pino'
+import { proto } from '../../WAProto'
+import { AuthenticationCreds, BaileysEventEmitter, Chat, GroupMetadata, ParticipantAction, SignalKeyStoreWithTransaction, SocketConfig, WAMessageStubType } from '../Types'
+import { getContentType, normalizeMessageContent } from '../Utils/messages'
+import { areJidsSameUser, isJidBroadcast, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary'
+import { aesDecryptGCM, hmacSign } from './crypto'
+import { getKeyAuthor, toNumber } from './generics'
+import { downloadAndProcessHistorySyncNotification } from './history'
+
+type ProcessMessageContext = {
+	shouldProcessHistoryMsg: boolean
+	creds: AuthenticationCreds
+	keyStore: SignalKeyStoreWithTransaction
+	ev: BaileysEventEmitter
+	getMessage: SocketConfig['getMessage']
+	logger?: Logger
+	options: AxiosRequestConfig<{}>
+}
+
+const REAL_MSG_STUB_TYPES = new Set([
+	WAMessageStubType.CALL_MISSED_GROUP_VIDEO,
+	WAMessageStubType.CALL_MISSED_GROUP_VOICE,
+	WAMessageStubType.CALL_MISSED_VIDEO,
+	WAMessageStubType.CALL_MISSED_VOICE
+])
+
+const REAL_MSG_REQ_ME_STUB_TYPES = new Set([
+	WAMessageStubType.GROUP_PARTICIPANT_ADD
+])
+
+/** Cleans a received message to further processing */
+export const cleanMessage = (message: proto.IWebMessageInfo, meId: string) => {
+	// ensure remoteJid and participant doesn't have device or agent in it
+	message.key.remoteJid = jidNormalizedUser(message.key.remoteJid!)
+	message.key.participant = message.key.participant ? jidNormalizedUser(message.key.participant!) : undefined
+	const content = normalizeMessageContent(message.message)
+	// if the message has a reaction, ensure fromMe & remoteJid are from our perspective
+	if(content?.reactionMessage) {
+		normaliseKey(content.reactionMessage.key!)
+	}
+
+	if(content?.pollUpdateMessage) {
+		normaliseKey(content.pollUpdateMessage.pollCreationMessageKey!)
+	}
+
+	function normaliseKey(msgKey: proto.IMessageKey) {
+		// if the reaction is from another user
+		// we've to correctly map the key to this user's perspective
+		if(!message.key.fromMe) {
+			// if the sender believed the message being reacted to is not from them
+			// we've to correct the key to be from them, or some other participant
+			msgKey.fromMe = !msgKey.fromMe
+				? areJidsSameUser(msgKey.participant || msgKey.remoteJid!, meId)
+				// if the message being reacted to, was from them
+				// fromMe automatically becomes false
+				: false
+			// set the remoteJid to being the same as the chat the message came from
+			msgKey.remoteJid = message.key.remoteJid
+			// set participant of the message
+			msgKey.participant = msgKey.participant || message.key.participant
+		}
+	}
+}
+
+export const isRealMessage = (message: proto.IWebMessageInfo, meId: string) => {
+	const normalizedContent = normalizeMessageContent(message.message)
+	const hasSomeContent = !!getContentType(normalizedContent)
+	return (
+		!!normalizedContent
+		|| REAL_MSG_STUB_TYPES.has(message.messageStubType!)
+		|| (
+			REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType!)
+			&& message.messageStubParameters?.some(p => areJidsSameUser(meId, p))
+		)
+	)
+	&& hasSomeContent
+	&& !normalizedContent?.protocolMessage
+	&& !normalizedContent?.reactionMessage
+	&& !normalizedContent?.pollUpdateMessage
+}
+
+export const shouldIncrementChatUnread = (message: proto.IWebMessageInfo) => (
+	!message.key.fromMe && !message.messageStubType
+)
+
+/**
+ * Get the ID of the chat from the given key.
+ * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
+ */
+export const getChatId = ({ remoteJid, participant, fromMe }: proto.IMessageKey) => {
+	if(
+		isJidBroadcast(remoteJid!)
+		&& !isJidStatusBroadcast(remoteJid!)
+		&& !fromMe
+	) {
+		return participant!
+	}
+
+	return remoteJid!
+}
+
+type PollContext = {
+	/** normalised jid of the person that created the poll */
+	pollCreatorJid: string
+	/** ID of the poll creation message */
+	pollMsgId: string
+	/** poll creation message enc key */
+	pollEncKey: Uint8Array
+	/** jid of the person that voted */
+	voterJid: string
+}
+
+/**
+ * Decrypt a poll vote
+ * @param vote encrypted vote
+ * @param ctx additional info about the poll required for decryption
+ * @returns list of SHA256 options
+ */
+export function decryptPollVote(
+	{ encPayload, encIv }: proto.Message.IPollEncValue,
+	{
+		pollCreatorJid,
+		pollMsgId,
+		pollEncKey,
+		voterJid,
+	}: PollContext
+) {
+	const sign = Buffer.concat(
+		[
+			toBinary(pollMsgId),
+			toBinary(pollCreatorJid),
+			toBinary(voterJid),
+			toBinary('Poll Vote'),
+			new Uint8Array([1])
+		]
+	)
+
+	const key0 = hmacSign(pollEncKey, new Uint8Array(32), 'sha256')
+	const decKey = hmacSign(sign, key0, 'sha256')
+	const aad = toBinary(`${pollMsgId}\u0000${voterJid}`)
+
+	const decrypted = aesDecryptGCM(encPayload!, decKey, encIv!, aad)
+	return proto.Message.PollVoteMessage.decode(decrypted)
+
+	function toBinary(txt: string) {
+		return Buffer.from(txt)
+	}
+}
+
+const processMessage = async(
+	message: proto.IWebMessageInfo,
+	{
+		shouldProcessHistoryMsg,
+		ev,
+		creds,
+		keyStore,
+		logger,
+		options,
+		getMessage
+	}: ProcessMessageContext
+) => {
+	const meId = creds.me!.id
+	const { accountSettings } = creds
+
+	const chat: Partial<Chat> = { id: jidNormalizedUser(getChatId(message.key)) }
+	const isRealMsg = isRealMessage(message, meId)
+
+	if(isRealMsg) {
+		chat.conversationTimestamp = toNumber(message.messageTimestamp)
+		// only increment unread count if not CIPHERTEXT and from another person
+		if(shouldIncrementChatUnread(message)) {
+			chat.unreadCount = (chat.unreadCount || 0) + 1
+		}
+	}
+
+	const content = normalizeMessageContent(message.message)
+
+	// unarchive chat if it's a real message, or someone reacted to our message
+	// and we've the unarchive chats setting on
+	if(
+		(isRealMsg || content?.reactionMessage?.key?.fromMe)
+		&& accountSettings?.unarchiveChats
+	) {
+		chat.archived = false
+		chat.readOnly = false
+	}
+
+	const protocolMsg = content?.protocolMessage
+	if(protocolMsg) {
+		switch (protocolMsg.type) {
+		case proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION:
+			const histNotification = protocolMsg!.historySyncNotification!
+			const process = shouldProcessHistoryMsg
+			const isLatest = !creds.processedHistoryMessages?.length
+
+			logger?.info({
+				histNotification,
+				process,
+				id: message.key.id,
+				isLatest,
+			}, 'got history notification')
+
+			if(process) {
+				ev.emit('creds.update', {
+					processedHistoryMessages: [
+						...(creds.processedHistoryMessages || []),
+						{ key: message.key, messageTimestamp: message.messageTimestamp }
+					]
+				})
+
+				const data = await downloadAndProcessHistorySyncNotification(
+					histNotification,
+					options
+				)
+
+				ev.emit('messaging-history.set', { ...data, isLatest })
+			}
+
+			break
+		case proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE:
+			const keys = protocolMsg.appStateSyncKeyShare!.keys
+			if(keys?.length) {
+				let newAppStateSyncKeyId = ''
+				await keyStore.transaction(
+					async() => {
+						const newKeys: string[] = []
+						for(const { keyData, keyId } of keys) {
+							const strKeyId = Buffer.from(keyId!.keyId!).toString('base64')
+							newKeys.push(strKeyId)
+
+							await keyStore.set({ 'app-state-sync-key': { [strKeyId]: keyData! } })
+
+							newAppStateSyncKeyId = strKeyId
+						}
+
+						logger?.info(
+							{ newAppStateSyncKeyId, newKeys },
+							'injecting new app state sync keys'
+						)
+					}
+				)
+
+				ev.emit('creds.update', { myAppStateKeyId: newAppStateSyncKeyId })
+			} else {
+				logger?.info({ protocolMsg }, 'recv app state sync with 0 keys')
+			}
+
+			break
+		case proto.Message.ProtocolMessage.Type.REVOKE:
+			ev.emit('messages.update', [
+				{
+					key: {
+						...message.key,
+						id: protocolMsg.key!.id
+					},
+					update: { message: null, messageStubType: WAMessageStubType.REVOKE, key: message.key }
+				}
+			])
+			break
+		case proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING:
+			Object.assign(chat, {
+				ephemeralSettingTimestamp: toNumber(message.messageTimestamp),
+				ephemeralExpiration: protocolMsg.ephemeralExpiration || null
+			})
+			break
+		case proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE:
+			const response = protocolMsg.peerDataOperationRequestResponseMessage!
+			if(response) {
+				const { peerDataOperationResult } = response
+				for(const result of peerDataOperationResult!) {
+					const { placeholderMessageResendResponse: retryResponse } = result
+					if(retryResponse) {
+						const webMessageInfo = proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes!)
+						ev.emit('messages.update', [
+							{ key: webMessageInfo.key, update: { message: webMessageInfo.message } }
+						])
+					}
+				}
+			}
+
+			break
+		}
+	} else if(content?.reactionMessage) {
+		const reaction: proto.IReaction = {
+			...content.reactionMessage,
+			key: message.key,
+		}
+		ev.emit('messages.reaction', [{
+			reaction,
+			key: content.reactionMessage!.key!,
+		}])
+	} else if(message.messageStubType) {
+		const jid = message.key!.remoteJid!
+		//let actor = whatsappID (message.participant)
+		let participants: string[]
+		const emitParticipantsUpdate = (action: ParticipantAction) => (
+			ev.emit('group-participants.update', { id: jid, author: message.participant!, participants, action })
+		)
+		const emitGroupUpdate = (update: Partial<GroupMetadata>) => {
+			ev.emit('groups.update', [{ id: jid, ...update, author: message.participant ?? undefined }])
+		}
+
+		const participantsIncludesMe = () => participants.find(jid => areJidsSameUser(meId, jid))
+
+		switch (message.messageStubType) {
+		case WAMessageStubType.GROUP_PARTICIPANT_LEAVE:
+		case WAMessageStubType.GROUP_PARTICIPANT_REMOVE:
+			participants = message.messageStubParameters || []
+			emitParticipantsUpdate('remove')
+			// mark the chat read only if you left the group
+			if(participantsIncludesMe()) {
+				chat.readOnly = true
+			}
+
+			break
+		case WAMessageStubType.GROUP_PARTICIPANT_ADD:
+		case WAMessageStubType.GROUP_PARTICIPANT_INVITE:
+		case WAMessageStubType.GROUP_PARTICIPANT_ADD_REQUEST_JOIN:
+			participants = message.messageStubParameters || []
+			if(participantsIncludesMe()) {
+				chat.readOnly = false
+			}
+
+			emitParticipantsUpdate('add')
+			break
+		case WAMessageStubType.GROUP_PARTICIPANT_DEMOTE:
+			participants = message.messageStubParameters || []
+			emitParticipantsUpdate('demote')
+			break
+		case WAMessageStubType.GROUP_PARTICIPANT_PROMOTE:
+			participants = message.messageStubParameters || []
+			emitParticipantsUpdate('promote')
+			break
+		case WAMessageStubType.GROUP_CHANGE_ANNOUNCE:
+			const announceValue = message.messageStubParameters?.[0]
+			emitGroupUpdate({ announce: announceValue === 'true' || announceValue === 'on' })
+			break
+		case WAMessageStubType.GROUP_CHANGE_RESTRICT:
+			const restrictValue = message.messageStubParameters?.[0]
+			emitGroupUpdate({ restrict: restrictValue === 'true' || restrictValue === 'on' })
+			break
+		case WAMessageStubType.GROUP_CHANGE_SUBJECT:
+			const name = message.messageStubParameters?.[0]
+			chat.name = name
+			emitGroupUpdate({ subject: name })
+			break
+		case WAMessageStubType.GROUP_CHANGE_INVITE_LINK:
+			const code = message.messageStubParameters?.[0]
+			emitGroupUpdate({ inviteCode: code })
+			break
+		case WAMessageStubType.GROUP_MEMBER_ADD_MODE:
+			const memberAddValue = message.messageStubParameters?.[0]
+			emitGroupUpdate({ memberAddMode: memberAddValue === 'all_member_add' })
+			break
+		case WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE:
+			const approvalMode = message.messageStubParameters?.[0]
+			emitGroupUpdate({ joinApprovalMode: approvalMode === 'on' })
+			break
+		}
+	} else if(content?.pollUpdateMessage) {
+		const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey!
+		// we need to fetch the poll creation message to get the poll enc key
+		const pollMsg = await getMessage(creationMsgKey)
+		if(pollMsg) {
+			const meIdNormalised = jidNormalizedUser(meId)
+			const pollCreatorJid = getKeyAuthor(creationMsgKey, meIdNormalised)
+			const voterJid = getKeyAuthor(message.key!, meIdNormalised)
+			const pollEncKey = pollMsg.messageContextInfo?.messageSecret!
+
+			try {
+				const voteMsg = decryptPollVote(
+					content.pollUpdateMessage.vote!,
+					{
+						pollEncKey,
+						pollCreatorJid,
+						pollMsgId: creationMsgKey.id!,
+						voterJid,
+					}
+				)
+				ev.emit('messages.update', [
+					{
+						key: creationMsgKey,
+						update: {
+							pollUpdates: [
+								{
+									pollUpdateMessageKey: message.key,
+									vote: voteMsg,
+									senderTimestampMs: (content.pollUpdateMessage.senderTimestampMs! as Long).toNumber(),
+								}
+							]
+						}
+					}
+				])
+			} catch(err) {
+				logger?.warn(
+					{ err, creationMsgKey },
+					'failed to decrypt poll vote'
+				)
+			}
+		} else {
+			logger?.warn(
+				{ creationMsgKey },
+				'poll creation message not found, cannot decrypt update'
+			)
+		}
+	}
+
+	if(Object.keys(chat).length > 1) {
+		ev.emit('chats.update', [chat])
+	}
+}
+
+export default processMessage

package/{lib → src}/Utils/signal.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 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");
@@ -12,13 +21,13 @@ const createSignalIdentity = (wid, accountSignatureKey) => {
     };
 };
 exports.createSignalIdentity = createSignalIdentity;
-const getPreKeys = async ({ get }, min, limit) => {
+const getPreKeys = (_a, min_1, limit_1) => __awaiter(void 0, [_a, min_1, limit_1], void 0, function* ({ 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;
@@ -56,7 +65,7 @@ const xmppPreKey = (pair, id) => ({
     ]
 });
 exports.xmppPreKey = xmppPreKey;
-const parseAndInjectE2ESessions = async (node, repository) => {
+const parseAndInjectE2ESessions = (node, repository) => __awaiter(void 0, void 0, void 0, function* () {
     const extractKey = (key) => (key ? ({
         keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
         publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
@@ -66,13 +75,13 @@ const parseAndInjectE2ESessions = async (node, repository) => {
     for (const node of nodes) {
         (0, WABinary_1.assertNodeErrorFree)(node);
     }
-    await Promise.all(nodes.map(async (node) => {
+    yield Promise.all(nodes.map((node) => __awaiter(void 0, void 0, void 0, function* () {
         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({
+        yield repository.injectE2ESession({
             jid,
             session: {
                 registrationId: registrationId,
@@ -81,8 +90,8 @@ const parseAndInjectE2ESessions = async (node, repository) => {
                 preKey: extractKey(key)
             }
         });
-    }));
-};
+    })));
+});
 exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
 const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
     var _a;
@@ -117,20 +126,20 @@ exports.extractDeviceJids = extractDeviceJids;
  * get the next N keys for upload or processing
  * @param count number of pre-keys to get or generate
  */
-const getNextPreKeys = async ({ creds, keys }, count) => {
+const getNextPreKeys = (_a, count_1) => __awaiter(void 0, [_a, count_1], void 0, function* ({ 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]);
+    yield keys.set({ 'pre-key': newPreKeys });
+    const preKeys = yield (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
     return { update, preKeys };
-};
+});
 exports.getNextPreKeys = getNextPreKeys;
-const getNextPreKeysNode = async (state, count) => {
+const getNextPreKeysNode = (state, count) => __awaiter(void 0, void 0, void 0, function* () {
     const { creds } = state;
-    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
+    const { update, preKeys } = yield (0, exports.getNextPreKeys)(state, count);
     const node = {
         tag: 'iq',
         attrs: {
@@ -147,5 +156,5 @@ const getNextPreKeysNode = async (state, count) => {
         ]
     };
     return { update, node };
-};
+});
 exports.getNextPreKeysNode = getNextPreKeysNode;

package/src/Utils/signal.ts

@@ -0,0 +1,177 @@
+import { KEY_BUNDLE_TYPE } from '../Defaults'
+import { SignalRepository } from '../Types'
+import { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth'
+import { assertNodeErrorFree, BinaryNode, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, jidDecode, JidWithDevice, S_WHATSAPP_NET } from '../WABinary'
+import { Curve, generateSignalPubKey } from './crypto'
+import { encodeBigEndian } from './generics'
+
+export const createSignalIdentity = (
+	wid: string,
+	accountSignatureKey: Uint8Array
+): SignalIdentity => {
+	return {
+		identifier: { name: wid, deviceId: 0 },
+		identifierKey: generateSignalPubKey(accountSignatureKey)
+	}
+}
+
+export const getPreKeys = async({ get }: SignalKeyStore, min: number, limit: number) => {
+	const idList: string[] = []
+	for(let id = min; id < limit;id++) {
+		idList.push(id.toString())
+	}
+
+	return get('pre-key', idList)
+}
+
+export const generateOrGetPreKeys = (creds: AuthenticationCreds, range: number) => {
+	const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
+	const remaining = range - avaliable
+	const lastPreKeyId = creds.nextPreKeyId + remaining - 1
+	const newPreKeys: { [id: number]: KeyPair } = { }
+	if(remaining > 0) {
+		for(let i = creds.nextPreKeyId;i <= lastPreKeyId;i++) {
+			newPreKeys[i] = Curve.generateKeyPair()
+		}
+	}
+
+	return {
+		newPreKeys,
+		lastPreKeyId,
+		preKeysRange: [creds.firstUnuploadedPreKeyId, range] as const,
+	}
+}
+
+export const xmppSignedPreKey = (key: SignedKeyPair): BinaryNode => (
+	{
+		tag: 'skey',
+		attrs: { },
+		content: [
+			{ tag: 'id', attrs: { }, content: encodeBigEndian(key.keyId, 3) },
+			{ tag: 'value', attrs: { }, content: key.keyPair.public },
+			{ tag: 'signature', attrs: { }, content: key.signature }
+		]
+	}
+)
+
+export const xmppPreKey = (pair: KeyPair, id: number): BinaryNode => (
+	{
+		tag: 'key',
+		attrs: { },
+		content: [
+			{ tag: 'id', attrs: { }, content: encodeBigEndian(id, 3) },
+			{ tag: 'value', attrs: { }, content: pair.public }
+		]
+	}
+)
+
+export const parseAndInjectE2ESessions = async(
+	node: BinaryNode,
+	repository: SignalRepository
+) => {
+	const extractKey = (key: BinaryNode) => (
+		key ? ({
+			keyId: getBinaryNodeChildUInt(key, 'id', 3)!,
+			publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')!)!,
+			signature: getBinaryNodeChildBuffer(key, 'signature')!,
+		}) : undefined
+	)
+	const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user')
+	for(const node of nodes) {
+		assertNodeErrorFree(node)
+	}
+
+	await Promise.all(
+		nodes.map(
+			async node => {
+				const signedKey = getBinaryNodeChild(node, 'skey')!
+				const key = getBinaryNodeChild(node, 'key')!
+				const identity = getBinaryNodeChildBuffer(node, 'identity')!
+				const jid = node.attrs.jid
+				const registrationId = getBinaryNodeChildUInt(node, 'registration', 4)
+
+				await repository.injectE2ESession({
+					jid,
+					session: {
+						registrationId: registrationId!,
+						identityKey: generateSignalPubKey(identity),
+						signedPreKey: extractKey(signedKey)!,
+						preKey: extractKey(key)!
+					}
+				})
+			}
+		)
+	)
+}
+
+export const extractDeviceJids = (result: BinaryNode, myJid: string, excludeZeroDevices: boolean) => {
+	const { user: myUser, device: myDevice } = jidDecode(myJid)!
+	const extracted: JidWithDevice[] = []
+	for(const node of result.content as BinaryNode[]) {
+		const list = getBinaryNodeChild(node, 'list')?.content
+		if(list && Array.isArray(list)) {
+			for(const item of list) {
+				const { user } = jidDecode(item.attrs.jid)!
+				const devicesNode = getBinaryNodeChild(item, 'devices')
+				const deviceListNode = getBinaryNodeChild(devicesNode, 'device-list')
+				if(Array.isArray(deviceListNode?.content)) {
+					for(const { tag, attrs } of deviceListNode!.content) {
+						const device = +attrs.id
+						if(
+							tag === 'device' && // ensure the "device" tag
+							(!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+							(myUser !== user || myDevice !== device) && // either different user or if me user, not this device
+							(device === 0 || !!attrs['key-index']) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+						) {
+							extracted.push({ user, device })
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return extracted
+}
+
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+export const getNextPreKeys = async({ creds, keys }: AuthenticationState, count: number) => {
+	const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count)
+
+	const update: Partial<AuthenticationCreds> = {
+		nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+		firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
+	}
+
+	await keys.set({ 'pre-key': newPreKeys })
+
+	const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
+
+	return { update, preKeys }
+}
+
+export const getNextPreKeysNode = async(state: AuthenticationState, count: number) => {
+	const { creds } = state
+	const { update, preKeys } = await getNextPreKeys(state, count)
+
+	const node: BinaryNode = {
+		tag: 'iq',
+		attrs: {
+			xmlns: 'encrypt',
+			type: 'set',
+			to: S_WHATSAPP_NET,
+		},
+		content: [
+			{ tag: 'registration', attrs: { }, content: encodeBigEndian(creds.registrationId) },
+			{ tag: 'type', attrs: { }, content: KEY_BUNDLE_TYPE },
+			{ tag: 'identity', attrs: { }, content: creds.signedIdentityKey.public },
+			{ tag: 'list', attrs: { }, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
+			xmppSignedPreKey(creds.signedPreKey)
+		]
+	}
+
+	return { update, node }
+}