@badzz88/baileys 8.4.7 → 8.5.0

package/lib/Utils/signal.js

@@ -1,201 +1,224 @@
-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';
+'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')
 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
 }
-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;
-};
+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
 /**
  * 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 }, 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
+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,3 +1,6 @@
+'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.
@@ -6,33 +9,32 @@
  * - WAWebHandleMsgSendAck.sendAck / sendNack
  * - WAWebCreateNackFromStanza.createNackFromStanza
  */
-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;
+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

package/lib/Utils/sticker.d.ts

@@ -0,0 +1,17 @@
+export interface StickerMetaOptions {
+	packName?: string
+	packPublisher?: string
+	categories?: string[]
+}
+
+export function addExifToWebp(webpBuffer: Buffer, options?: StickerMetaOptions): Promise<Buffer>
+
+export function imageToWebpSticker(
+	imageBuffer: Buffer,
+	options?: StickerMetaOptions & { quality?: number }
+): Promise<Buffer>
+
+export function videoToWebpSticker(
+	videoBuffer: Buffer,
+	options?: StickerMetaOptions & { fps?: number; seconds?: number }
+): Promise<Buffer>