@badzz88/baileys 8.5.6 → 8.5.8

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

@@ -1,28 +1,28 @@
-'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 = void 0;
-exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
-const node_cache_1 = __importDefault(require('@cacheable/node-cache'));
-const async_hooks_1 = require('async_hooks');
-const async_mutex_1 = require('async-mutex');
-const crypto_1 = require('crypto');
-const p_queue_1 = __importDefault(require('p-queue'));
-const Defaults_1 = require('../Defaults');
-const crypto_2 = require('./crypto');
-const generics_1 = require('./generics');
-const pre_key_manager_1 = require('./pre-key-manager');
-function makeCacheableSignalKeyStore(store, logger, _cache) {
+import NodeCache from '@cacheable/node-cache';
+import { Boom } from '@hapi/boom';
+import { AsyncLocalStorage } from 'async_hooks';
+import { Mutex } from 'async-mutex';
+import { randomBytes } from 'crypto';
+import PQueue from 'p-queue';
+import { DEFAULT_CACHE_TTLS } from '../Defaults/index.js';
+import { Curve, signedKeyPair } from './crypto.js';
+import { delay, generateRegistrationId } from './generics.js';
+import { PreKeyManager } from './pre-key-manager.js';
+/**
+ * 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, logger, _cache) {
     const cache = _cache ||
-        new node_cache_1.default({
-            stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        new NodeCache({
+            stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
             useClones: false,
             deleteOnExpire: true
         });
-    const cacheMutex = new async_mutex_1.Mutex();
+    // Mutex for protecting cache operations
+    const cacheMutex = new Mutex();
     function getUniqueId(type, id) {
         return `${type}.${id}`;
     }
@@ -32,7 +32,7 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
                 const data = {};
                 const idsToFetch = [];
                 for (const id of ids) {
-                    const item = await cache.get(getUniqueId(type, id));
+                    const item = (await cache.get(getUniqueId(type, id)));
                     if (typeof item !== 'undefined') {
                         data[id] = item;
                     }
@@ -47,6 +47,7 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
                         const item = fetched[id];
                         if (item) {
                             data[id] = item;
+                            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
                             await cache.set(getUniqueId(type, id), item);
                         }
                     }
@@ -73,32 +74,55 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
         }
     };
 }
-const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
-    const txStorage = new async_hooks_1.AsyncLocalStorage();
+/**
+ * Adds DB-like transaction capability to the SignalKeyStore
+ * Uses AsyncLocalStorage for automatic context management
+ * @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, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    const txStorage = new AsyncLocalStorage();
+    // Queues for concurrency control (keyed by signal data type - bounded set)
     const keyQueues = new Map();
+    // Transaction mutexes with reference counting for cleanup
     const txMutexes = new Map();
     const txMutexRefCounts = new Map();
-    const preKeyManager = new pre_key_manager_1.PreKeyManager(state, logger);
+    // Pre-key manager for specialized operations
+    const preKeyManager = new PreKeyManager(state, logger);
+    /**
+     * Get or create a queue for a specific key type
+     */
     function getQueue(key) {
         if (!keyQueues.has(key)) {
-            keyQueues.set(key, new p_queue_1.default({ concurrency: 1 }));
+            keyQueues.set(key, new PQueue({ concurrency: 1 }));
         }
         return keyQueues.get(key);
     }
+    /**
+     * Get or create a transaction mutex
+     */
     function getTxMutex(key) {
         if (!txMutexes.has(key)) {
-            txMutexes.set(key, new async_mutex_1.Mutex());
+            txMutexes.set(key, new Mutex());
             txMutexRefCounts.set(key, 0);
         }
         return txMutexes.get(key);
     }
+    /**
+     * Acquire a reference to a transaction mutex
+     */
     function acquireTxMutexRef(key) {
         const count = txMutexRefCounts.get(key) ?? 0;
         txMutexRefCounts.set(key, count + 1);
     }
+    /**
+     * Release a reference to a transaction mutex and cleanup if no longer needed
+     */
     function releaseTxMutexRef(key) {
         const count = (txMutexRefCounts.get(key) ?? 1) - 1;
         txMutexRefCounts.set(key, count);
+        // Cleanup if no more references and mutex is not locked
         if (count <= 0) {
             const mutex = txMutexes.get(key);
             if (mutex && !mutex.isLocked()) {
@@ -107,9 +131,15 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             }
         }
     }
+    /**
+     * Check if currently in a transaction
+     */
     function isInTransaction() {
         return !!txStorage.getStore();
     }
+    /**
+     * Commit transaction with retries
+     */
     async function commitWithRetry(mutations) {
         if (Object.keys(mutations).length === 0) {
             logger.trace('no mutations in transaction');
@@ -128,7 +158,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                 if (retriesLeft === 0) {
                     throw error;
                 }
-                await (0, generics_1.delay)(delayBetweenTriesMs);
+                await delay(delayBetweenTriesMs);
             }
         }
     }
@@ -136,17 +166,21 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
         get: async (type, ids) => {
             const ctx = txStorage.getStore();
             if (!ctx) {
+                // No transaction - direct read without exclusive lock for concurrency
                 return state.get(type, ids);
             }
+            // In transaction - check cache first
             const cached = ctx.cache[type] || {};
             const missing = ids.filter(id => !(id in cached));
             if (missing.length > 0) {
                 ctx.dbQueries++;
                 logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction');
                 const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing));
+                // Update cache
                 ctx.cache[type] = ctx.cache[type] || {};
                 Object.assign(ctx.cache[type], fetched);
             }
+            // Return requested ids from cache
             const result = {};
             for (const id of ids) {
                 const value = ctx.cache[type]?.[id];
@@ -159,28 +193,35 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
         set: async (data) => {
             const ctx = txStorage.getStore();
             if (!ctx) {
+                // No transaction - direct write with queue protection
                 const types = Object.keys(data);
+                // Process pre-keys with validation
                 for (const type_ of types) {
                     const type = type_;
                     if (type === 'pre-key') {
                         await preKeyManager.validateDeletions(data, type);
                     }
                 }
+                // Write all data in parallel
                 await Promise.all(types.map(type => getQueue(type).add(async () => {
                     const typeData = { [type]: data[type] };
                     await state.set(typeData);
                 })));
                 return;
             }
+            // In transaction - update cache and mutations
             logger.trace({ types: Object.keys(data) }, 'caching in transaction');
             for (const key_ in data) {
                 const key = key_;
+                // Ensure structures exist
                 ctx.cache[key] = ctx.cache[key] || {};
                 ctx.mutations[key] = ctx.mutations[key] || {};
+                // Special handling for pre-keys
                 if (key === 'pre-key') {
                     await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true);
                 }
                 else {
+                    // Normal key types
                     Object.assign(ctx.cache[key], data[key]);
                     Object.assign(ctx.mutations[key], data[key]);
                 }
@@ -189,10 +230,12 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
         isInTransaction,
         transaction: async (work, key) => {
             const existing = txStorage.getStore();
+            // Nested transaction - reuse existing context
             if (existing) {
                 logger.trace('reusing existing transaction context');
                 return work();
             }
+            // New transaction - acquire mutex and create context
             const mutex = getTxMutex(key);
             acquireTxMutexRef(key);
             try {
@@ -205,6 +248,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                     logger.trace('entering transaction');
                     try {
                         const result = await txStorage.run(ctx, work);
+                        // Commit mutations
                         await commitWithRetry(ctx.mutations);
                         logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed');
                         return result;
@@ -221,29 +265,33 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
         }
     };
 };
-exports.addTransactionCapability = addTransactionCapability;
-const initAuthCreds = () => {
-    const identityKey = crypto_2.Curve.generateKeyPair();
+/**
+ * Returns the authenticated user's JID, or throws a Boom-401 if creds are not yet authenticated.
+ * Use this anywhere we'd otherwise reach for `creds.me!.id` to fail fast with a descriptive error.
+ */
+export const assertMeId = (creds) => {
+    const id = creds.me?.id;
+    if (!id) {
+        throw new Boom('Cannot proceed: socket is not authenticated yet (creds.me.id is missing)', { statusCode: 401 });
+    }
+    return id;
+};
+export const initAuthCreds = () => {
+    const identityKey = Curve.generateKeyPair();
     return {
-        noiseKey: crypto_2.Curve.generateKeyPair(),
-        pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
+        noiseKey: Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: Curve.generateKeyPair(),
         signedIdentityKey: identityKey,
-        signedPreKey: (0, crypto_2.signedKeyPair)(identityKey, 1),
-        registrationId: (0, generics_1.generateRegistrationId)(),
-        advSecretKey: (0, crypto_1.randomBytes)(32).toString('base64'),
+        signedPreKey: signedKeyPair(identityKey, 1),
+        registrationId: generateRegistrationId(),
+        advSecretKey: randomBytes(32).toString('base64'),
         processedHistoryMessages: [],
-        initialFullSyncDone: false,
         nextPreKeyId: 1,
         firstUnuploadedPreKeyId: 1,
         accountSyncCounter: 0,
         accountSettings: {
             unarchiveChats: false
         },
-        deviceId: Buffer.from((0, crypto_1.randomUUID)().replace(/-/g, ''), 'hex').toString('base64url'),
-        phoneId: (0, crypto_1.randomUUID)(),
-        identityId: (0, crypto_1.randomBytes)(20),
-        backupToken: (0, crypto_1.randomBytes)(20),
-        registration: {},
         registered: false,
         pairingCode: undefined,
         lastPropHash: undefined,
@@ -251,4 +299,4 @@ const initAuthCreds = () => {
         additionalData: undefined
     };
 };
-exports.initAuthCreds = initAuthCreds;
+//# sourceMappingURL=auth-utils.js.map

package/lib/Utils/browser-utils.js

@@ -0,0 +1,48 @@
+import { platform, release } from 'os';
+import { proto } from '../../WAProto/index.js';
+const PLATFORM_MAP = {
+    aix: 'AIX',
+    darwin: 'Mac OS',
+    win32: 'Windows',
+    android: 'Android',
+    freebsd: 'FreeBSD',
+    openbsd: 'OpenBSD',
+    sunos: 'Solaris',
+    linux: 'Linux',
+    haiku: undefined,
+    cygwin: undefined,
+    netbsd: undefined
+};
+const BROWSER_MAP = {
+    safari: 'Safari',
+    chrome: 'Chrome',
+    edge: 'Edge',
+    firefox: 'Firefox',
+    opera: 'Opera',
+    brave: 'Brave',
+    samsung: 'Samsung Internet'
+};
+const getBrowserN = (bros) => {
+    const brosN = BROWSER_MAP[bros] || bros;
+    return brosN;
+};
+export const Browsers = {
+    ubuntu: browser => ['Ubuntu', getBrowserN(browser), '22.04.4'],
+    macOS: browser => ['Mac OS', getBrowserN(browser), '14.4.1'],
+    baileys: browser => ['Baileys', getBrowserN(browser), '6.5.0'],
+    windows: browser => ['Windows', getBrowserN(browser), '10.0.22631'],
+    iOS: browser => ['iOS', getBrowserN(browser), '18.2'],
+    android: browser => ['Android', getBrowserN(browser), '14.0.0'],
+    safari: browser => ['Safari', getBrowserN(browser), '26.5'],
+    custom: (platform, browser, ver) => {
+        let platformN = PLATFORM_MAP[platform].toLowerCase() || platform;
+        return [platformN, getBrowserN(browser), ver];
+    },
+    /** The appropriate browser based on your OS & release */
+    appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', getBrowserN(browser), release()]
+};
+export const getPlatformId = (browser) => {
+    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+    return platformType ? platformType.toString() : '1'; //chrome
+};
+//# sourceMappingURL=browser-utils.js.map

package/lib/Utils/business.js

@@ -0,0 +1,231 @@
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { createWriteStream, promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString } from '../WABinary/index.js';
+import { generateMessageIDV2 } from './generics.js';
+import { getStream, getUrlFromDirectPath } from './messages-media.js';
+export const parseCatalogNode = (node) => {
+    const catalogNode = getBinaryNodeChild(node, 'product_catalog');
+    const products = getBinaryNodeChildren(catalogNode, 'product').map(parseProductNode);
+    const paging = getBinaryNodeChild(catalogNode, 'paging');
+    return {
+        products,
+        nextPageCursor: paging ? getBinaryNodeChildString(paging, 'after') : undefined
+    };
+};
+export const parseCollectionsNode = (node) => {
+    const collectionsNode = getBinaryNodeChild(node, 'collections');
+    const collections = getBinaryNodeChildren(collectionsNode, 'collection').map(collectionNode => {
+        const id = getBinaryNodeChildString(collectionNode, 'id');
+        const name = getBinaryNodeChildString(collectionNode, 'name');
+        const products = getBinaryNodeChildren(collectionNode, 'product').map(parseProductNode);
+        return {
+            id,
+            name,
+            products,
+            status: parseStatusInfo(collectionNode)
+        };
+    });
+    return {
+        collections
+    };
+};
+export const parseOrderDetailsNode = (node) => {
+    const orderNode = getBinaryNodeChild(node, 'order');
+    const products = getBinaryNodeChildren(orderNode, 'product').map(productNode => {
+        const imageNode = getBinaryNodeChild(productNode, 'image');
+        return {
+            id: getBinaryNodeChildString(productNode, 'id'),
+            name: getBinaryNodeChildString(productNode, 'name'),
+            imageUrl: getBinaryNodeChildString(imageNode, 'url'),
+            price: +getBinaryNodeChildString(productNode, 'price'),
+            currency: getBinaryNodeChildString(productNode, 'currency'),
+            quantity: +getBinaryNodeChildString(productNode, 'quantity')
+        };
+    });
+    const priceNode = getBinaryNodeChild(orderNode, 'price');
+    const orderDetails = {
+        price: {
+            total: +getBinaryNodeChildString(priceNode, 'total'),
+            currency: getBinaryNodeChildString(priceNode, 'currency')
+        },
+        products
+    };
+    return orderDetails;
+};
+export const toProductNode = (productId, product) => {
+    const attrs = {};
+    const content = [];
+    if (typeof productId !== 'undefined') {
+        content.push({
+            tag: 'id',
+            attrs: {},
+            content: Buffer.from(productId)
+        });
+    }
+    if (typeof product.name !== 'undefined') {
+        content.push({
+            tag: 'name',
+            attrs: {},
+            content: Buffer.from(product.name)
+        });
+    }
+    if (typeof product.description !== 'undefined') {
+        content.push({
+            tag: 'description',
+            attrs: {},
+            content: Buffer.from(product.description)
+        });
+    }
+    if (typeof product.retailerId !== 'undefined') {
+        content.push({
+            tag: 'retailer_id',
+            attrs: {},
+            content: Buffer.from(product.retailerId)
+        });
+    }
+    if (product.images.length) {
+        content.push({
+            tag: 'media',
+            attrs: {},
+            content: product.images.map(img => {
+                if (!('url' in img)) {
+                    throw new Boom('Expected img for product to already be uploaded', { statusCode: 400 });
+                }
+                return {
+                    tag: 'image',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'url',
+                            attrs: {},
+                            content: Buffer.from(img.url.toString())
+                        }
+                    ]
+                };
+            })
+        });
+    }
+    if (typeof product.price !== 'undefined') {
+        content.push({
+            tag: 'price',
+            attrs: {},
+            content: Buffer.from(product.price.toString())
+        });
+    }
+    if (typeof product.currency !== 'undefined') {
+        content.push({
+            tag: 'currency',
+            attrs: {},
+            content: Buffer.from(product.currency)
+        });
+    }
+    if ('originCountryCode' in product) {
+        if (typeof product.originCountryCode === 'undefined') {
+            attrs['compliance_category'] = 'COUNTRY_ORIGIN_EXEMPT';
+        }
+        else {
+            content.push({
+                tag: 'compliance_info',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'country_code_origin',
+                        attrs: {},
+                        content: Buffer.from(product.originCountryCode)
+                    }
+                ]
+            });
+        }
+    }
+    if (typeof product.isHidden !== 'undefined') {
+        attrs['is_hidden'] = product.isHidden.toString();
+    }
+    const node = {
+        tag: 'product',
+        attrs,
+        content
+    };
+    return node;
+};
+export const parseProductNode = (productNode) => {
+    const isHidden = productNode.attrs.is_hidden === 'true';
+    const id = getBinaryNodeChildString(productNode, 'id');
+    const mediaNode = getBinaryNodeChild(productNode, 'media');
+    const statusInfoNode = getBinaryNodeChild(productNode, 'status_info');
+    const product = {
+        id,
+        imageUrls: parseImageUrls(mediaNode),
+        reviewStatus: {
+            whatsapp: getBinaryNodeChildString(statusInfoNode, 'status')
+        },
+        availability: 'in stock',
+        name: getBinaryNodeChildString(productNode, 'name'),
+        retailerId: getBinaryNodeChildString(productNode, 'retailer_id'),
+        url: getBinaryNodeChildString(productNode, 'url'),
+        description: getBinaryNodeChildString(productNode, 'description'),
+        price: +getBinaryNodeChildString(productNode, 'price'),
+        currency: getBinaryNodeChildString(productNode, 'currency'),
+        isHidden
+    };
+    return product;
+};
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
+    product = {
+        ...product,
+        images: product.images
+            ? await uploadingNecessaryImages(product.images, waUploadToServer, timeoutMs)
+            : product.images
+    };
+    return product;
+}
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 30000) => {
+    const results = await Promise.all(images.map(async (img) => {
+        if ('url' in img) {
+            const url = img.url.toString();
+            if (url.includes('.whatsapp.net')) {
+                return { url };
+            }
+        }
+        const { stream } = await getStream(img);
+        const hasher = createHash('sha256');
+        const filePath = join(tmpdir(), 'img' + generateMessageIDV2());
+        const encFileWriteStream = createWriteStream(filePath);
+        for await (const block of stream) {
+            hasher.update(block);
+            encFileWriteStream.write(block);
+        }
+        const sha = hasher.digest('base64');
+        const { directPath } = await waUploadToServer(filePath, {
+            mediaType: 'product-catalog-image',
+            fileEncSha256B64: sha,
+            timeoutMs
+        });
+        await fs.unlink(filePath).catch(err => console.log('Error deleting temp file ', err));
+        return { url: getUrlFromDirectPath(directPath) };
+    }));
+    return results;
+};
+const parseImageUrls = (mediaNode) => {
+    const imgNode = getBinaryNodeChild(mediaNode, 'image');
+    return {
+        requested: getBinaryNodeChildString(imgNode, 'request_image_url'),
+        original: getBinaryNodeChildString(imgNode, 'original_image_url')
+    };
+};
+const parseStatusInfo = (mediaNode) => {
+    const node = getBinaryNodeChild(mediaNode, 'status_info');
+    return {
+        status: getBinaryNodeChildString(node, 'status'),
+        canAppeal: getBinaryNodeChildString(node, 'can_appeal') === 'true'
+    };
+};
+//# sourceMappingURL=business.js.map