gifted-baileys 1.5.0 → 1.5.5

package/{lib → src}/Utils/auth-utils.js

@@ -1,9 +1,19 @@
 "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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initAuthCreds = exports.addTransactionCapability = exports.makeCacheableSignalKeyStore = void 0;
+exports.initAuthCreds = exports.addTransactionCapability = void 0;
+exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
 const crypto_1 = require("crypto");
 const node_cache_1 = __importDefault(require("node-cache"));
 const uuid_1 = require("uuid");
@@ -18,7 +28,7 @@ const generics_1 = require("./generics");
  */
 function makeCacheableSignalKeyStore(store, logger, _cache) {
     const cache = _cache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
         useClones: false,
         deleteOnExpire: true,
     });
@@ -26,50 +36,55 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
         return `${type}.${id}`;
     }
     return {
-        async get(type, ids) {
-            const data = {};
-            const idsToFetch = [];
-            for (const id of ids) {
-                const item = cache.get(getUniqueId(type, id));
-                if (typeof item !== 'undefined') {
-                    data[id] = item;
-                }
-                else {
-                    idsToFetch.push(id);
-                }
-            }
-            if (idsToFetch.length) {
-                logger.trace({ items: idsToFetch.length }, 'loading from store');
-                const fetched = await store.get(type, idsToFetch);
-                for (const id of idsToFetch) {
-                    const item = fetched[id];
-                    if (item) {
+        get(type, ids) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const data = {};
+                const idsToFetch = [];
+                for (const id of ids) {
+                    const item = cache.get(getUniqueId(type, id));
+                    if (typeof item !== 'undefined') {
                         data[id] = item;
-                        cache.set(getUniqueId(type, id), item);
+                    }
+                    else {
+                        idsToFetch.push(id);
                     }
                 }
-            }
-            return data;
+                if (idsToFetch.length) {
+                    logger.trace({ items: idsToFetch.length }, 'loading from store');
+                    const fetched = yield store.get(type, idsToFetch);
+                    for (const id of idsToFetch) {
+                        const item = fetched[id];
+                        if (item) {
+                            data[id] = item;
+                            cache.set(getUniqueId(type, id), item);
+                        }
+                    }
+                }
+                return data;
+            });
         },
-        async set(data) {
-            let keys = 0;
-            for (const type in data) {
-                for (const id in data[type]) {
-                    cache.set(getUniqueId(type, id), data[type][id]);
-                    keys += 1;
+        set(data) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let keys = 0;
+                for (const type in data) {
+                    for (const id in data[type]) {
+                        cache.set(getUniqueId(type, id), data[type][id]);
+                        keys += 1;
+                    }
                 }
-            }
-            logger.trace({ keys }, 'updated cache');
-            await store.set(data);
+                logger.trace({ keys }, 'updated cache');
+                yield store.set(data);
+            });
         },
-        async clear() {
-            var _a;
-            cache.flushAll();
-            await ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store));
+        clear() {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                cache.flushAll();
+                yield ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store));
+            });
         }
     };
 }
-exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
 /**
  * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
  * this allows batch read & write operations & improves the performance of the lib
@@ -85,7 +100,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
     let mutations = {};
     let transactionsInProgress = 0;
     return {
-        get: async (type, ids) => {
+        get: (type, ids) => __awaiter(void 0, void 0, void 0, function* () {
             if (isInTransaction()) {
                 const dict = transactionCache[type];
                 const idsRequiringFetch = dict
@@ -94,7 +109,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                 // only fetch if there are any items to fetch
                 if (idsRequiringFetch.length) {
                     dbQueriesInTransaction += 1;
-                    const result = await state.get(type, idsRequiringFetch);
+                    const result = yield state.get(type, idsRequiringFetch);
                     transactionCache[type] || (transactionCache[type] = {});
                     Object.assign(transactionCache[type], result);
                 }
@@ -110,7 +125,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             else {
                 return state.get(type, ids);
             }
-        },
+        }),
         set: data => {
             if (isInTransaction()) {
                 logger.trace({ types: Object.keys(data) }, 'caching in transaction');
@@ -126,48 +141,50 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             }
         },
         isInTransaction,
-        async transaction(work) {
-            let result;
-            transactionsInProgress += 1;
-            if (transactionsInProgress === 1) {
-                logger.trace('entering transaction');
-            }
-            try {
-                result = await work();
-                // commit if this is the outermost transaction
+        transaction(work) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let result;
+                transactionsInProgress += 1;
                 if (transactionsInProgress === 1) {
-                    if (Object.keys(mutations).length) {
-                        logger.trace('committing transaction');
-                        // retry mechanism to ensure we've some recovery
-                        // in case a transaction fails in the first attempt
-                        let tries = maxCommitRetries;
-                        while (tries) {
-                            tries -= 1;
-                            try {
-                                await state.set(mutations);
-                                logger.trace({ dbQueriesInTransaction }, 'committed transaction');
-                                break;
-                            }
-                            catch (error) {
-                                logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
-                                await (0, generics_1.delay)(delayBetweenTriesMs);
+                    logger.trace('entering transaction');
+                }
+                try {
+                    result = yield work();
+                    // commit if this is the outermost transaction
+                    if (transactionsInProgress === 1) {
+                        if (Object.keys(mutations).length) {
+                            logger.trace('committing transaction');
+                            // retry mechanism to ensure we've some recovery
+                            // in case a transaction fails in the first attempt
+                            let tries = maxCommitRetries;
+                            while (tries) {
+                                tries -= 1;
+                                try {
+                                    yield state.set(mutations);
+                                    logger.trace({ dbQueriesInTransaction }, 'committed transaction');
+                                    break;
+                                }
+                                catch (error) {
+                                    logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
+                                    yield (0, generics_1.delay)(delayBetweenTriesMs);
+                                }
                             }
                         }
-                    }
-                    else {
-                        logger.trace('no mutations in transaction');
+                        else {
+                            logger.trace('no mutations in transaction');
+                        }
                     }
                 }
-            }
-            finally {
-                transactionsInProgress -= 1;
-                if (transactionsInProgress === 0) {
-                    transactionCache = {};
-                    mutations = {};
-                    dbQueriesInTransaction = 0;
+                finally {
+                    transactionsInProgress -= 1;
+                    if (transactionsInProgress === 0) {
+                        transactionCache = {};
+                        mutations = {};
+                        dbQueriesInTransaction = 0;
+                    }
                 }
-            }
-            return result;
+                return result;
+            });
         }
     };
     function isInTransaction() {
@@ -199,6 +216,8 @@ const initAuthCreds = () => {
         backupToken: (0, crypto_1.randomBytes)(20),
         registration: {},
         pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
     };
 };
 exports.initAuthCreds = initAuthCreds;

package/src/Utils/auth-utils.ts

@@ -0,0 +1,222 @@
+import { randomBytes } from 'crypto'
+import NodeCache from 'node-cache'
+import type { Logger } from 'pino'
+import { v4 as uuidv4 } from 'uuid'
+import { DEFAULT_CACHE_TTLS } from '../Defaults'
+import type { AuthenticationCreds, CacheStore, SignalDataSet, SignalDataTypeMap, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types'
+import { Curve, signedKeyPair } from './crypto'
+import { delay, generateRegistrationId } from './generics'
+
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export function makeCacheableSignalKeyStore(
+	store: SignalKeyStore,
+	logger: Logger,
+	_cache?: CacheStore
+): SignalKeyStore {
+	const cache = _cache || new NodeCache({
+		stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
+		useClones: false,
+		deleteOnExpire: true,
+	})
+
+	function getUniqueId(type: string, id: string) {
+		return `${type}.${id}`
+	}
+
+	return {
+		async get(type, ids) {
+			const data: { [_: string]: SignalDataTypeMap[typeof type] } = { }
+			const idsToFetch: string[] = []
+			for(const id of ids) {
+				const item = cache.get<SignalDataTypeMap[typeof type]>(getUniqueId(type, id))
+				if(typeof item !== 'undefined') {
+					data[id] = item
+				} else {
+					idsToFetch.push(id)
+				}
+			}
+
+			if(idsToFetch.length) {
+				logger.trace({ items: idsToFetch.length }, 'loading from store')
+				const fetched = await store.get(type, idsToFetch)
+				for(const id of idsToFetch) {
+					const item = fetched[id]
+					if(item) {
+						data[id] = item
+						cache.set(getUniqueId(type, id), item)
+					}
+				}
+			}
+
+			return data
+		},
+		async set(data) {
+			let keys = 0
+			for(const type in data) {
+				for(const id in data[type]) {
+					cache.set(getUniqueId(type, id), data[type][id])
+					keys += 1
+				}
+			}
+
+			logger.trace({ keys }, 'updated cache')
+
+			await store.set(data)
+		},
+		async clear() {
+			cache.flushAll()
+			await store.clear?.()
+		}
+	}
+}
+
+/**
+ * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
+ * this allows batch read & write operations & improves the performance of the lib
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export const addTransactionCapability = (
+	state: SignalKeyStore,
+	logger: Logger,
+	{ maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions
+): SignalKeyStoreWithTransaction => {
+	// number of queries made to the DB during the transaction
+	// only there for logging purposes
+	let dbQueriesInTransaction = 0
+	let transactionCache: SignalDataSet = { }
+	let mutations: SignalDataSet = { }
+
+	let transactionsInProgress = 0
+
+	return {
+		get: async(type, ids) => {
+			if(isInTransaction()) {
+				const dict = transactionCache[type]
+				const idsRequiringFetch = dict
+					? ids.filter(item => typeof dict[item] === 'undefined')
+					: ids
+				// only fetch if there are any items to fetch
+				if(idsRequiringFetch.length) {
+					dbQueriesInTransaction += 1
+					const result = await state.get(type, idsRequiringFetch)
+
+					transactionCache[type] ||= {}
+					Object.assign(
+						transactionCache[type]!,
+						result
+					)
+				}
+
+				return ids.reduce(
+					(dict, id) => {
+						const value = transactionCache[type]?.[id]
+						if(value) {
+							dict[id] = value
+						}
+
+						return dict
+					}, { }
+				)
+			} else {
+				return state.get(type, ids)
+			}
+		},
+		set: data => {
+			if(isInTransaction()) {
+				logger.trace({ types: Object.keys(data) }, 'caching in transaction')
+				for(const key in data) {
+					transactionCache[key] = transactionCache[key] || { }
+					Object.assign(transactionCache[key], data[key])
+
+					mutations[key] = mutations[key] || { }
+					Object.assign(mutations[key], data[key])
+				}
+			} else {
+				return state.set(data)
+			}
+		},
+		isInTransaction,
+		async transaction(work) {
+			let result: Awaited<ReturnType<typeof work>>
+			transactionsInProgress += 1
+			if(transactionsInProgress === 1) {
+				logger.trace('entering transaction')
+			}
+
+			try {
+				result = await work()
+				// commit if this is the outermost transaction
+				if(transactionsInProgress === 1) {
+					if(Object.keys(mutations).length) {
+						logger.trace('committing transaction')
+						// retry mechanism to ensure we've some recovery
+						// in case a transaction fails in the first attempt
+						let tries = maxCommitRetries
+						while(tries) {
+							tries -= 1
+							try {
+								await state.set(mutations)
+								logger.trace({ dbQueriesInTransaction }, 'committed transaction')
+								break
+							} catch(error) {
+								logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`)
+								await delay(delayBetweenTriesMs)
+							}
+						}
+					} else {
+						logger.trace('no mutations in transaction')
+					}
+				}
+			} finally {
+				transactionsInProgress -= 1
+				if(transactionsInProgress === 0) {
+					transactionCache = { }
+					mutations = { }
+					dbQueriesInTransaction = 0
+				}
+			}
+
+			return result
+		}
+	}
+
+	function isInTransaction() {
+		return transactionsInProgress > 0
+	}
+}
+
+export const initAuthCreds = (): AuthenticationCreds => {
+	const identityKey = Curve.generateKeyPair()
+	return {
+		noiseKey: Curve.generateKeyPair(),
+		pairingEphemeralKeyPair: Curve.generateKeyPair(),
+		signedIdentityKey: identityKey,
+		signedPreKey: signedKeyPair(identityKey, 1),
+		registrationId: generateRegistrationId(),
+		advSecretKey: randomBytes(32).toString('base64'),
+		processedHistoryMessages: [],
+		nextPreKeyId: 1,
+		firstUnuploadedPreKeyId: 1,
+		accountSyncCounter: 0,
+		accountSettings: {
+			unarchiveChats: false
+		},
+		// mobile creds
+		deviceId: Buffer.from(uuidv4().replace(/-/g, ''), 'hex').toString('base64url'),
+		phoneId: uuidv4(),
+		identityId: randomBytes(20),
+		registered: false,
+		backupToken: randomBytes(20),
+		registration: {} as never,
+		pairingCode: undefined,
+		lastPropHash: undefined,
+		routingInfo: undefined,
+	}
+}

package/src/Utils/baileys-event-stream.js

@@ -0,0 +1,92 @@
+"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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAndEmitEventStream = exports.captureEventStream = void 0;
+const events_1 = __importDefault(require("events"));
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const readline_1 = require("readline");
+const generics_1 = require("./generics");
+const make_mutex_1 = require("./make-mutex");
+/**
+ * Captures events from a baileys event emitter & stores them in a file
+ * @param ev The event emitter to read events from
+ * @param filename File to save to
+ */
+const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit;
+    // write mutex so data is appended in order
+    const writeMutex = (0, make_mutex_1.makeMutex)();
+    // monkey patch eventemitter to capture all events
+    ev.emit = function (...args) {
+        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n';
+        const result = oldEmit.apply(ev, args);
+        writeMutex.mutex(() => __awaiter(this, void 0, void 0, function* () {
+            yield (0, promises_1.writeFile)(filename, content, { flag: 'a' });
+        }));
+        return result;
+    };
+};
+exports.captureEventStream = captureEventStream;
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new events_1.default();
+    const fireEvents = () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        // from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
+        const fileStream = (0, fs_1.createReadStream)(filename);
+        const rl = (0, readline_1.createInterface)({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        try {
+            // Note: we use the crlfDelay option to recognize all instances of CR LF
+            // ('\r\n') in input.txt as a single line break.
+            for (var _d = true, rl_1 = __asyncValues(rl), rl_1_1; rl_1_1 = yield rl_1.next(), _a = rl_1_1.done, !_a; _d = true) {
+                _c = rl_1_1.value;
+                _d = false;
+                const line = _c;
+                if (line) {
+                    const { event, data } = JSON.parse(line);
+                    ev.emit(event, data);
+                    delayIntervalMs && (yield (0, generics_1.delay)(delayIntervalMs));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = rl_1.return)) yield _b.call(rl_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        fileStream.close();
+    });
+    return {
+        ev,
+        task: fireEvents()
+    };
+};
+exports.readAndEmitEventStream = readAndEmitEventStream;

package/src/Utils/baileys-event-stream.ts

@@ -0,0 +1,66 @@
+import EventEmitter from 'events'
+import { createReadStream } from 'fs'
+import { writeFile } from 'fs/promises'
+import { createInterface } from 'readline'
+import type { BaileysEventEmitter } from '../Types'
+import { delay } from './generics'
+import { makeMutex } from './make-mutex'
+
+/**
+ * Captures events from a baileys event emitter & stores them in a file
+ * @param ev The event emitter to read events from
+ * @param filename File to save to
+ */
+export const captureEventStream = (ev: BaileysEventEmitter, filename: string) => {
+	const oldEmit = ev.emit
+	// write mutex so data is appended in order
+	const writeMutex = makeMutex()
+	// monkey patch eventemitter to capture all events
+	ev.emit = function(...args: any[]) {
+		const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n'
+		const result = oldEmit.apply(ev, args)
+
+		writeMutex.mutex(
+			async() => {
+				await writeFile(filename, content, { flag: 'a' })
+			}
+		)
+
+		return result
+	}
+}
+
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+export const readAndEmitEventStream = (filename: string, delayIntervalMs: number = 0) => {
+	const ev = new EventEmitter() as BaileysEventEmitter
+
+	const fireEvents = async() => {
+		// from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
+		const fileStream = createReadStream(filename)
+
+		const rl = createInterface({
+			input: fileStream,
+			crlfDelay: Infinity
+		})
+		// Note: we use the crlfDelay option to recognize all instances of CR LF
+		// ('\r\n') in input.txt as a single line break.
+		for await (const line of rl) {
+			if(line) {
+				const { event, data } = JSON.parse(line)
+				ev.emit(event, data)
+				delayIntervalMs && await delay(delayIntervalMs)
+			}
+		}
+
+		fileStream.close()
+	}
+
+	return {
+		ev,
+		task: fireEvents()
+	}
+}