gifted-baileys 1.5.4 → 1.5.6

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 }
+}

package/{lib → src}/Utils/use-multi-file-auth-state.js

@@ -1,6 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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.useMultiFileAuthState = void 0;
@@ -9,8 +15,6 @@ const path_1 = require("path");
 const WAProto_1 = require("../../WAProto");
 const auth_utils_1 = require("./auth-utils");
 const generics_1 = require("./generics");
-const async_lock_1 = __importDefault(require("async-lock"));
-const fileLock = new async_lock_1.default({ maxPending: Infinity });
 /**
  * stores the full authentication state in a single folder.
  * Far more efficient than singlefileauthstate
@@ -18,56 +22,53 @@ const fileLock = new async_lock_1.default({ maxPending: Infinity });
  * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
  * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
  * */
-const useMultiFileAuthState = async (folder) => {
+const useMultiFileAuthState = (folder) => __awaiter(void 0, void 0, void 0, function* () {
     const writeData = (data, file) => {
-        const filePath = (0, path_1.join)(folder, fixFileName(file));
-        return fileLock.acquire(filePath, () => (0, promises_1.writeFile)((0, path_1.join)(filePath), JSON.stringify(data, generics_1.BufferJSON.replacer)));
+        return (0, promises_1.writeFile)((0, path_1.join)(folder, fixFileName(file)), JSON.stringify(data, generics_1.BufferJSON.replacer));
     };
-    const readData = async (file) => {
+    const readData = (file) => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
-            const data = await fileLock.acquire(filePath, () => (0, promises_1.readFile)(filePath, { encoding: 'utf-8' }));
+            const data = yield (0, promises_1.readFile)((0, path_1.join)(folder, fixFileName(file)), { encoding: 'utf-8' });
             return JSON.parse(data, generics_1.BufferJSON.reviver);
         }
         catch (error) {
             return null;
         }
-    };
-    const removeData = async (file) => {
+    });
+    const removeData = (file) => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
-            await fileLock.acquire(filePath, () => (0, promises_1.unlink)(filePath));
+            yield (0, promises_1.unlink)((0, path_1.join)(folder, fixFileName(file)));
         }
         catch (_a) {
         }
-    };
-    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
+    });
+    const folderInfo = yield (0, promises_1.stat)(folder).catch(() => { });
     if (folderInfo) {
         if (!folderInfo.isDirectory()) {
             throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
         }
     }
     else {
-        await (0, promises_1.mkdir)(folder, { recursive: true });
+        yield (0, promises_1.mkdir)(folder, { recursive: true });
     }
     const fixFileName = (file) => { var _a; return (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.replace(/:/g, '-'); };
-    const creds = await readData('creds.json') || (0, auth_utils_1.initAuthCreds)();
+    const creds = (yield readData('creds.json')) || (0, auth_utils_1.initAuthCreds)();
     return {
         state: {
             creds,
             keys: {
-                get: async (type, ids) => {
+                get: (type, ids) => __awaiter(void 0, void 0, void 0, function* () {
                     const data = {};
-                    await Promise.all(ids.map(async (id) => {
-                        let value = await readData(`${type}-${id}.json`);
+                    yield Promise.all(ids.map((id) => __awaiter(void 0, void 0, void 0, function* () {
+                        let value = yield readData(`${type}-${id}.json`);
                         if (type === 'app-state-sync-key' && value) {
                             value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
                         }
                         data[id] = value;
-                    }));
+                    })));
                     return data;
-                },
-                set: async (data) => {
+                }),
+                set: (data) => __awaiter(void 0, void 0, void 0, function* () {
                     const tasks = [];
                     for (const category in data) {
                         for (const id in data[category]) {
@@ -76,13 +77,13 @@ const useMultiFileAuthState = async (folder) => {
                             tasks.push(value ? writeData(value, file) : removeData(file));
                         }
                     }
-                    await Promise.all(tasks);
-                }
+                    yield Promise.all(tasks);
+                })
             }
         },
         saveCreds: () => {
             return writeData(creds, 'creds.json');
         }
     };
-};
+});
 exports.useMultiFileAuthState = useMultiFileAuthState;

package/src/Utils/use-multi-file-auth-state.ts

@@ -0,0 +1,90 @@
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises'
+import { join } from 'path'
+import { proto } from '../../WAProto'
+import { AuthenticationCreds, AuthenticationState, SignalDataTypeMap } from '../Types'
+import { initAuthCreds } from './auth-utils'
+import { BufferJSON } from './generics'
+
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+export const useMultiFileAuthState = async(folder: string): Promise<{ state: AuthenticationState, saveCreds: () => Promise<void> }> => {
+
+	const writeData = (data: any, file: string) => {
+		return writeFile(join(folder, fixFileName(file)!), JSON.stringify(data, BufferJSON.replacer))
+	}
+
+	const readData = async(file: string) => {
+		try {
+			const data = await readFile(join(folder, fixFileName(file)!), { encoding: 'utf-8' })
+			return JSON.parse(data, BufferJSON.reviver)
+		} catch(error) {
+			return null
+		}
+	}
+
+	const removeData = async(file: string) => {
+		try {
+			await unlink(join(folder, fixFileName(file)!))
+		} catch{
+
+		}
+	}
+
+	const folderInfo = await stat(folder).catch(() => { })
+	if(folderInfo) {
+		if(!folderInfo.isDirectory()) {
+			throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`)
+		}
+	} else {
+		await mkdir(folder, { recursive: true })
+	}
+
+	const fixFileName = (file?: string) => file?.replace(/\//g, '__')?.replace(/:/g, '-')
+
+	const creds: AuthenticationCreds = await readData('creds.json') || initAuthCreds()
+
+	return {
+		state: {
+			creds,
+			keys: {
+				get: async(type, ids) => {
+					const data: { [_: string]: SignalDataTypeMap[typeof type] } = { }
+					await Promise.all(
+						ids.map(
+							async id => {
+								let value = await readData(`${type}-${id}.json`)
+								if(type === 'app-state-sync-key' && value) {
+									value = proto.Message.AppStateSyncKeyData.fromObject(value)
+								}
+
+								data[id] = value
+							}
+						)
+					)
+
+					return data
+				},
+				set: async(data) => {
+					const tasks: Promise<void>[] = []
+					for(const category in data) {
+						for(const id in data[category]) {
+							const value = data[category][id]
+							const file = `${category}-${id}.json`
+							tasks.push(value ? writeData(value, file) : removeData(file))
+						}
+					}
+
+					await Promise.all(tasks)
+				}
+			}
+		},
+		saveCreds: () => {
+			return writeData(creds, 'creds.json')
+		}
+	}
+}

package/{lib → src}/Utils/validate-connection.js

@@ -17,24 +17,12 @@ const getUserAgent = (config) => {
     const manufacturer = config.mobile ? 'Apple' : '';
     const platform = config.mobile ? WAProto_1.proto.ClientPayload.UserAgent.Platform.IOS : WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB;
     const phoneId = config.mobile ? { phoneId: config.auth.creds.phoneId } : {};
-    return {
-        appVersion: {
+    return Object.assign({ appVersion: {
             primary: version[0],
             secondary: version[1],
             tertiary: version[2],
-        },
-        platform,
-        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
-        mcc: ((_a = config.auth.creds.registration) === null || _a === void 0 ? void 0 : _a.phoneNumberMobileCountryCode) || '000',
-        mnc: ((_b = config.auth.creds.registration) === null || _b === void 0 ? void 0 : _b.phoneNumberMobileNetworkCode) || '000',
-        osVersion: osVersion,
-        manufacturer,
-        device,
-        osBuildNumber: osVersion,
-        localeLanguageIso6391: 'en',
-        localeCountryIso31661Alpha2: 'US',
-        ...phoneId
-    };
+        }, platform, releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE, mcc: ((_a = config.auth.creds.registration) === null || _a === void 0 ? void 0 : _a.phoneNumberMobileCountryCode) || '000', mnc: ((_b = config.auth.creds.registration) === null || _b === void 0 ? void 0 : _b.phoneNumberMobileNetworkCode) || '000', osVersion: osVersion, manufacturer,
+        device, osBuildNumber: osVersion, localeLanguageIso6391: 'en', localeCountryIso31661Alpha2: 'US' }, phoneId);
 };
 const PLATFORM_MAP = {
     'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
@@ -62,31 +50,16 @@ const generateMobileNode = (config) => {
     if (!config.auth.creds) {
         throw new boom_1.Boom('No registration data found', { data: config });
     }
-    const payload = {
-        ...getClientPayload(config),
-        sessionId: Math.floor(Math.random() * 999999999 + 1),
-        shortConnect: true,
-        connectAttemptCount: 0,
-        device: 0,
-        dnsSource: {
+    const payload = Object.assign(Object.assign({}, getClientPayload(config)), { sessionId: Math.floor(Math.random() * 999999999 + 1), shortConnect: true, connectAttemptCount: 0, device: 0, dnsSource: {
             appCached: false,
             dnsMethod: WAProto_1.proto.ClientPayload.DNSSource.DNSResolutionMethod.SYSTEM,
-        },
-        passive: false,
-        pushName: 'test',
-        username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`),
-    };
+        }, passive: false, pushName: 'test', username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`) });
     return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
 exports.generateMobileNode = generateMobileNode;
 const generateLoginNode = (userJid, config) => {
     const { user, device } = (0, WABinary_1.jidDecode)(userJid);
-    const payload = {
-        ...getClientPayload(config),
-        passive: true,
-        username: +user,
-        device: device,
-    };
+    const payload = Object.assign(Object.assign({}, getClientPayload(config)), { passive: true, username: +user, device: device });
     return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
 exports.generateLoginNode = generateLoginNode;
@@ -106,10 +79,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         requireFullSync: config.syncFullHistory,
     };
     const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish();
-    const registerPayload = {
-        ...getClientPayload(config),
-        passive: false,
-        devicePairingData: {
+    const registerPayload = Object.assign(Object.assign({}, getClientPayload(config)), { passive: false, devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
             eRegid: (0, generics_1.encodeBigEndian)(registrationId),
@@ -118,8 +88,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
             eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
             eSkeySig: signedPreKey.signature,
-        },
-    };
+        } });
     return WAProto_1.proto.ClientPayload.fromObject(registerPayload);
 };
 exports.generateRegistrationNode = generateRegistrationNode;
@@ -192,7 +161,7 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
 exports.configureSuccessfulPairing = configureSuccessfulPairing;
 const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
     var _a;
-    account = { ...account };
+    account = Object.assign({}, account);
     // set to null if we are not to include the signature key
     // or if we are including the signature key but it is empty
     if (!includeSignatureKey || !((_a = account.accountSignatureKey) === null || _a === void 0 ? void 0 : _a.length)) {