@badzz88/baileys 8.5.7 → 8.5.9

package/lib/Utils/signal.js

@@ -1,224 +1,201 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.getNextPreKeysNode =
-	exports.getNextPreKeys =
-	exports.extractDeviceJids =
-	exports.parseAndInjectE2ESessions =
-	exports.extractE2ESessionFromRetryReceipt =
-	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')
+import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
+import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from '../WABinary/index.js';
+import { Curve, generateSignalPubKey } from './crypto.js';
+import { encodeBigEndian } from './generics.js';
 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 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 => ({
-	tag: 'skey',
-	attrs: {},
-	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) => ({
-	tag: 'key',
-	attrs: {},
-	content: [
-		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
-		{ tag: 'value', attrs: {}, content: pair.public }
-	]
-})
-exports.xmppPreKey = xmppPreKey
-const isValidUInt = n => typeof n === 'number' && Number.isInteger(n)
-const extractE2ESessionFromRetryReceipt = receipt => {
-	const keysNode = (0, WABinary_1.getBinaryNodeChild)(receipt, 'keys')
-	if (!keysNode) return null
-	const typeBuf = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'type')
-	if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== Defaults_1.KEY_BUNDLE_TYPE[0]) return null
-	const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'identity')
-	const skey = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'skey')
-	if (!identity || identity.length !== 32 || !skey) return null
-	const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(receipt, 'registration', 4)
-	if (!isValidUInt(registrationId)) return null
-	const signedPubKey = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'value')
-	const signedSig = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'signature')
-	const signedKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(skey, 'id', 3)
-	if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
-		return null
-	}
-	const preKeyNode = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'key')
-	let preKey
-	if (preKeyNode) {
-		const preKeyPub = (0, WABinary_1.getBinaryNodeChildBuffer)(preKeyNode, 'value')
-		const preKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(preKeyNode, 'id', 3)
-		if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
-			return null
-		}
-		preKey = { keyId: preKeyId, publicKey: (0, crypto_1.generateSignalPubKey)(preKeyPub) }
-	}
-	return {
-		registrationId,
-		identityKey: (0, crypto_1.generateSignalPubKey)(identity),
-		signedPreKey: {
-			keyId: signedKeyId,
-			publicKey: (0, crypto_1.generateSignalPubKey)(signedPubKey),
-			signature: signedSig
-		},
-		preKey
-	}
-}
-exports.extractE2ESessionFromRetryReceipt = extractE2ESessionFromRetryReceipt
-const parseAndInjectE2ESessions = async (node, repository) => {
-	const extractKey = key =>
-		key
-			? {
-					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')
-				}
-			: undefined
-	const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user')
-	for (const node of nodes) {
-		;(0, WABinary_1.assertNodeErrorFree)(node)
-	}
-	// Most of the work in repository.injectE2ESession is CPU intensive, not IO
-	// So Promise.all doesn't really help here,
-	// but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
-	// This way we chunk it in smaller parts and between those parts we can yield to the event loop
-	// It's rare case when you need to E2E sessions for so many users, but it's possible
-	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) && // if zero devices are not-excluded, or device is non zero
-				((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
-				(device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-			) {
-				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
+export const createSignalIdentity = (wid, accountSignatureKey) => {
+    return {
+        identifier: { name: wid, deviceId: 0 },
+        identifierKey: generateSignalPubKey(accountSignatureKey)
+    };
+};
+export const getPreKeys = async ({ get }, min, limit) => {
+    const idList = [];
+    for (let id = min; id < limit; id++) {
+        idList.push(id.toString());
+    }
+    return get('pre-key', idList);
+};
+export 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] = Curve.generateKeyPair();
+        }
+    }
+    return {
+        newPreKeys,
+        lastPreKeyId,
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+    };
+};
+export const xmppSignedPreKey = (key) => ({
+    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, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: 'value', attrs: {}, content: pair.public }
+    ]
+});
+const isValidUInt = (n) => typeof n === 'number' && Number.isInteger(n);
+export const extractE2ESessionFromRetryReceipt = (receipt) => {
+    const keysNode = getBinaryNodeChild(receipt, 'keys');
+    if (!keysNode)
+        return null;
+    const typeBuf = getBinaryNodeChildBuffer(keysNode, 'type');
+    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0])
+        return null;
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity');
+    const skey = getBinaryNodeChild(keysNode, 'skey');
+    if (!identity || identity.length !== 32 || !skey)
+        return null;
+    const registrationId = getBinaryNodeChildUInt(receipt, 'registration', 4);
+    if (!isValidUInt(registrationId))
+        return null;
+    const signedPubKey = getBinaryNodeChildBuffer(skey, 'value');
+    const signedSig = getBinaryNodeChildBuffer(skey, 'signature');
+    const signedKeyId = getBinaryNodeChildUInt(skey, 'id', 3);
+    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
+        return null;
+    }
+    const preKeyNode = getBinaryNodeChild(keysNode, 'key');
+    let preKey;
+    if (preKeyNode) {
+        const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, 'value');
+        const preKeyId = getBinaryNodeChildUInt(preKeyNode, 'id', 3);
+        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
+            return null;
+        }
+        preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) };
+    }
+    return {
+        registrationId,
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: {
+            keyId: signedKeyId,
+            publicKey: generateSignalPubKey(signedPubKey),
+            signature: signedSig
+        },
+        preKey
+    };
+};
+export const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => 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);
+    }
+    // Most of the work in repository.injectE2ESession is CPU intensive, not IO
+    // So Promise.all doesn't really help here,
+    // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
+    // This way we chunk it in smaller parts and between those parts we can yield to the event loop
+    // It's rare case when you need to E2E sessions for so many users, but it's possible
+    const chunkSize = 100;
+    const chunks = chunk(nodes, chunkSize);
+    for (const nodesChunk of chunks) {
+        for (const node of nodesChunk) {
+            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, myJid, myLid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = jidDecode(myJid);
+    const extracted = [];
+    for (const userResult of result) {
+        const { devices, id } = userResult;
+        const decoded = 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) && // if zero devices are not-excluded, or device is non zero
+                ((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
+                (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+            ) {
+                if (isHosted) {
+                    domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
+                }
+                extracted.push({
+                    user,
+                    device,
+                    domainType,
+                    server: getServerFromDomainType(server, domainType)
+                });
+            }
+        }
+    }
+    return extracted;
+};
 /**
  * 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 { 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
+export const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = 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 getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    return { update, preKeys };
+};
+export const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state;
+    const { update, preKeys } = await getNextPreKeys(state, count);
+    const node = {
+        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 };
+};
+//# sourceMappingURL=signal.js.map

package/lib/Utils/stanza-ack.js

@@ -1,6 +1,3 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.buildAckStanza = buildAckStanza
 /**
  * Builds an ACK stanza for a received node.
  * Pure function -- no I/O, no side effects.
@@ -9,32 +6,33 @@ exports.buildAckStanza = buildAckStanza
  * - WAWebHandleMsgSendAck.sendAck / sendNack
  * - WAWebCreateNackFromStanza.createNackFromStanza
  */
-function buildAckStanza(node, errorCode, meId) {
-	const { tag, attrs } = node
-	const stanza = {
-		tag: 'ack',
-		attrs: {
-			id: attrs.id,
-			to: attrs.from,
-			class: tag
-		}
-	}
-	if (errorCode) {
-		stanza.attrs.error = errorCode.toString()
-	}
-	if (attrs.participant) {
-		stanza.attrs.participant = attrs.participant
-	}
-	if (attrs.recipient) {
-		stanza.attrs.recipient = attrs.recipient
-	}
-	// WA Web always includes type when present: `n.type || DROP_ATTR`
-	if (attrs.type) {
-		stanza.attrs.type = attrs.type
-	}
-	// WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
-	if (tag === 'message' && meId) {
-		stanza.attrs.from = meId
-	}
-	return stanza
+export function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node;
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    };
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString();
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant;
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient;
+    }
+    // WA Web always includes type when present: `n.type || DROP_ATTR`
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+    // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
 }
+//# sourceMappingURL=stanza-ack.js.map