@queenanya/baileys 6.7.0 → 6.8.0

package/lib/Types/index.d.ts

@@ -1,56 +1,56 @@
-export * from './Auth';
-export * from './GroupMetadata';
-export * from './Chat';
-export * from './Contact';
-export * from './State';
-export * from './Message';
-export * from './Socket';
-export * from './Events';
-export * from './Product';
-export * from './Call';
-export * from './Signal';
-import { AuthenticationState } from './Auth';
-import { SocketConfig } from './Socket';
-export type UserFacingSocketConfig = Partial<SocketConfig> & {
-    auth: AuthenticationState;
-};
-export declare enum DisconnectReason {
-    connectionClosed = 428,
-    connectionLost = 408,
-    connectionReplaced = 440,
-    timedOut = 408,
-    loggedOut = 401,
-    badSession = 500,
-    restartRequired = 515,
-    multideviceMismatch = 411,
-    forbidden = 403,
-    unavailableService = 503
-}
-export type WAInitResponse = {
-    ref: string;
-    ttl: number;
-    status: 200;
-};
-export type WABusinessHoursConfig = {
-    day_of_week: string;
-    mode: string;
-    open_time?: number;
-    close_time?: number;
-};
-export type WABusinessProfile = {
-    description: string;
-    email: string | undefined;
-    business_hours: {
-        timezone?: string;
-        config?: WABusinessHoursConfig[];
-        business_config?: WABusinessHoursConfig[];
-    };
-    website: string[];
-    category?: string;
-    wid?: string;
-    address?: string;
-};
-export type CurveKeyPair = {
-    private: Uint8Array;
-    public: Uint8Array;
-};
+export * from './Auth';
+export * from './GroupMetadata';
+export * from './Chat';
+export * from './Contact';
+export * from './State';
+export * from './Message';
+export * from './Socket';
+export * from './Events';
+export * from './Product';
+export * from './Call';
+export * from './Signal';
+import { AuthenticationState } from './Auth';
+import { SocketConfig } from './Socket';
+export type UserFacingSocketConfig = Partial<SocketConfig> & {
+    auth: AuthenticationState;
+};
+export declare enum DisconnectReason {
+    connectionClosed = 428,
+    connectionLost = 408,
+    connectionReplaced = 440,
+    timedOut = 408,
+    loggedOut = 401,
+    badSession = 500,
+    restartRequired = 515,
+    multideviceMismatch = 411,
+    forbidden = 403,
+    unavailableService = 503
+}
+export type WAInitResponse = {
+    ref: string;
+    ttl: number;
+    status: 200;
+};
+export type WABusinessHoursConfig = {
+    day_of_week: string;
+    mode: string;
+    open_time?: number;
+    close_time?: number;
+};
+export type WABusinessProfile = {
+    description: string;
+    email: string | undefined;
+    business_hours: {
+        timezone?: string;
+        config?: WABusinessHoursConfig[];
+        business_config?: WABusinessHoursConfig[];
+    };
+    website: string[];
+    category?: string;
+    wid?: string;
+    address?: string;
+};
+export type CurveKeyPair = {
+    private: Uint8Array;
+    public: Uint8Array;
+};

package/lib/Types/index.js

@@ -1,41 +1,41 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DisconnectReason = void 0;
-__exportStar(require("./Auth"), exports);
-__exportStar(require("./GroupMetadata"), exports);
-__exportStar(require("./Chat"), exports);
-__exportStar(require("./Contact"), exports);
-__exportStar(require("./State"), exports);
-__exportStar(require("./Message"), exports);
-__exportStar(require("./Socket"), exports);
-__exportStar(require("./Events"), exports);
-__exportStar(require("./Product"), exports);
-__exportStar(require("./Call"), exports);
-__exportStar(require("./Signal"), exports);
-var DisconnectReason;
-(function (DisconnectReason) {
-    DisconnectReason[DisconnectReason["connectionClosed"] = 428] = "connectionClosed";
-    DisconnectReason[DisconnectReason["connectionLost"] = 408] = "connectionLost";
-    DisconnectReason[DisconnectReason["connectionReplaced"] = 440] = "connectionReplaced";
-    DisconnectReason[DisconnectReason["timedOut"] = 408] = "timedOut";
-    DisconnectReason[DisconnectReason["loggedOut"] = 401] = "loggedOut";
-    DisconnectReason[DisconnectReason["badSession"] = 500] = "badSession";
-    DisconnectReason[DisconnectReason["restartRequired"] = 515] = "restartRequired";
-    DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
-    DisconnectReason[DisconnectReason["forbidden"] = 403] = "forbidden";
-    DisconnectReason[DisconnectReason["unavailableService"] = 503] = "unavailableService";
-})(DisconnectReason = exports.DisconnectReason || (exports.DisconnectReason = {}));
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisconnectReason = void 0;
+__exportStar(require("./Auth"), exports);
+__exportStar(require("./GroupMetadata"), exports);
+__exportStar(require("./Chat"), exports);
+__exportStar(require("./Contact"), exports);
+__exportStar(require("./State"), exports);
+__exportStar(require("./Message"), exports);
+__exportStar(require("./Socket"), exports);
+__exportStar(require("./Events"), exports);
+__exportStar(require("./Product"), exports);
+__exportStar(require("./Call"), exports);
+__exportStar(require("./Signal"), exports);
+var DisconnectReason;
+(function (DisconnectReason) {
+    DisconnectReason[DisconnectReason["connectionClosed"] = 428] = "connectionClosed";
+    DisconnectReason[DisconnectReason["connectionLost"] = 408] = "connectionLost";
+    DisconnectReason[DisconnectReason["connectionReplaced"] = 440] = "connectionReplaced";
+    DisconnectReason[DisconnectReason["timedOut"] = 408] = "timedOut";
+    DisconnectReason[DisconnectReason["loggedOut"] = 401] = "loggedOut";
+    DisconnectReason[DisconnectReason["badSession"] = 500] = "badSession";
+    DisconnectReason[DisconnectReason["restartRequired"] = 515] = "restartRequired";
+    DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
+    DisconnectReason[DisconnectReason["forbidden"] = 403] = "forbidden";
+    DisconnectReason[DisconnectReason["unavailableService"] = 503] = "unavailableService";
+})(DisconnectReason = exports.DisconnectReason || (exports.DisconnectReason = {}));

package/lib/Utils/auth-utils.d.ts

@@ -1,18 +1,18 @@
-import type { Logger } from 'pino';
-import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types';
-/**
- * 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 declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger: Logger, _cache?: CacheStore): SignalKeyStore;
-/**
- * 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 declare const addTransactionCapability: (state: SignalKeyStore, logger: Logger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction;
-export declare const initAuthCreds: () => AuthenticationCreds;
+import type { Logger } from 'pino';
+import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types';
+/**
+ * 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 declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger: Logger, _cache?: CacheStore): SignalKeyStore;
+/**
+ * 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 declare const addTransactionCapability: (state: SignalKeyStore, logger: Logger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction;
+export declare const initAuthCreds: () => AuthenticationCreds;

package/lib/Utils/auth-utils.js

@@ -1,204 +1,204 @@
-"use strict";
-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;
-const crypto_1 = require("crypto");
-const node_cache_1 = __importDefault(require("node-cache"));
-const uuid_1 = require("uuid");
-const Defaults_1 = require("../Defaults");
-const crypto_2 = require("./crypto");
-const generics_1 = require("./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
- */
-function makeCacheableSignalKeyStore(store, logger, _cache) {
-    const cache = _cache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
-        useClones: false,
-        deleteOnExpire: true,
-    });
-    function getUniqueId(type, id) {
-        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) {
-                        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() {
-            var _a;
-            cache.flushAll();
-            await ((_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
- * @param state the key store to apply this capability to
- * @param logger logger to log events
- * @returns SignalKeyStore with transaction capability
- */
-const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
-    // number of queries made to the DB during the transaction
-    // only there for logging purposes
-    let dbQueriesInTransaction = 0;
-    let transactionCache = {};
-    let mutations = {};
-    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] || (transactionCache[type] = {});
-                    Object.assign(transactionCache[type], result);
-                }
-                return ids.reduce((dict, id) => {
-                    var _a;
-                    const value = (_a = transactionCache[type]) === null || _a === void 0 ? void 0 : _a[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;
-            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 (0, generics_1.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;
-    }
-};
-exports.addTransactionCapability = addTransactionCapability;
-const initAuthCreds = () => {
-    const identityKey = crypto_2.Curve.generateKeyPair();
-    return {
-        noiseKey: crypto_2.Curve.generateKeyPair(),
-        pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
-        signedIdentityKey: identityKey,
-        signedPreKey: (0, crypto_2.signedKeyPair)(identityKey, 1),
-        registrationId: (0, generics_1.generateRegistrationId)(),
-        advSecretKey: (0, crypto_1.randomBytes)(32).toString('base64'),
-        processedHistoryMessages: [],
-        nextPreKeyId: 1,
-        firstUnuploadedPreKeyId: 1,
-        accountSyncCounter: 0,
-        accountSettings: {
-            unarchiveChats: false
-        },
-        // mobile creds
-        deviceId: Buffer.from((0, uuid_1.v4)().replace(/-/g, ''), 'hex').toString('base64url'),
-        phoneId: (0, uuid_1.v4)(),
-        identityId: (0, crypto_1.randomBytes)(20),
-        registered: false,
-        backupToken: (0, crypto_1.randomBytes)(20),
-        registration: {},
-        pairingCode: undefined,
-    };
-};
-exports.initAuthCreds = initAuthCreds;
+"use strict";
+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;
+const crypto_1 = require("crypto");
+const node_cache_1 = __importDefault(require("node-cache"));
+const uuid_1 = require("uuid");
+const Defaults_1 = require("../Defaults");
+const crypto_2 = require("./crypto");
+const generics_1 = require("./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
+ */
+function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache = _cache || new node_cache_1.default({
+        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        useClones: false,
+        deleteOnExpire: true,
+    });
+    function getUniqueId(type, id) {
+        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) {
+                        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() {
+            var _a;
+            cache.flushAll();
+            await ((_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
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    // number of queries made to the DB during the transaction
+    // only there for logging purposes
+    let dbQueriesInTransaction = 0;
+    let transactionCache = {};
+    let mutations = {};
+    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] || (transactionCache[type] = {});
+                    Object.assign(transactionCache[type], result);
+                }
+                return ids.reduce((dict, id) => {
+                    var _a;
+                    const value = (_a = transactionCache[type]) === null || _a === void 0 ? void 0 : _a[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;
+            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 (0, generics_1.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;
+    }
+};
+exports.addTransactionCapability = addTransactionCapability;
+const initAuthCreds = () => {
+    const identityKey = crypto_2.Curve.generateKeyPair();
+    return {
+        noiseKey: crypto_2.Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: (0, crypto_2.signedKeyPair)(identityKey, 1),
+        registrationId: (0, generics_1.generateRegistrationId)(),
+        advSecretKey: (0, crypto_1.randomBytes)(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: {
+            unarchiveChats: false
+        },
+        // mobile creds
+        deviceId: Buffer.from((0, uuid_1.v4)().replace(/-/g, ''), 'hex').toString('base64url'),
+        phoneId: (0, uuid_1.v4)(),
+        identityId: (0, crypto_1.randomBytes)(20),
+        registered: false,
+        backupToken: (0, crypto_1.randomBytes)(20),
+        registration: {},
+        pairingCode: undefined,
+    };
+};
+exports.initAuthCreds = initAuthCreds;