@hbmodsofc/baileys 1.5.2 → 1.7.6

package/lib/Utils/auth-utils.js

@@ -3,10 +3,12 @@ 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 node_cache_1 = __importDefault(require("@cacheable/node-cache"));
+const async_mutex_1 = require("async-mutex");
 const crypto_1 = require("crypto");
-const node_cache_1 = __importDefault(require("node-cache"));
-const uuid_1 = require("uuid");
+const lru_cache_1 = require("lru-cache");
 const Defaults_1 = require("../Defaults");
 const crypto_2 = require("./crypto");
 const generics_1 = require("./generics");
@@ -17,59 +19,203 @@ const generics_1 = require("./generics");
  * @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,
-    });
+    const cache = _cache ||
+        new node_cache_1.default({
+            stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
+            useClones: false,
+            deleteOnExpire: true
+        });
+    // Mutex for protecting cache operations
+    const cacheMutex = new async_mutex_1.Mutex();
     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) {
+            return cacheMutex.runExclusive(async () => {
+                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 = 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;
+            return cacheMutex.runExclusive(async () => {
+                let keys = 0;
+                for (const type in data) {
+                    for (const id in data[type]) {
+                        await cache.set(getUniqueId(type, id), data[type][id]);
+                        keys += 1;
+                    }
                 }
-            }
-            logger.trace({ keys }, 'updated cache');
-            await store.set(data);
+                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));
+            await cache.flushAll();
+            await store.clear?.();
         }
     };
 }
-exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
+// Module-level specialized mutexes for pre-key operations
+const preKeyMutex = new async_mutex_1.Mutex();
+const signedPreKeyMutex = new async_mutex_1.Mutex();
+/**
+ * Get the appropriate mutex for the key type
+ */
+const getPreKeyMutex = (keyType) => {
+    return keyType === 'signed-pre-key' ? signedPreKeyMutex : preKeyMutex;
+};
+/**
+ * Handles pre-key operations with mutex protection
+ */
+async function handlePreKeyOperations(data, keyType, transactionCache, mutations, logger, isInTransaction, state) {
+    const mutex = getPreKeyMutex(keyType);
+    await mutex.runExclusive(async () => {
+        const keyData = data[keyType];
+        if (!keyData)
+            return;
+        // Ensure structures exist
+        transactionCache[keyType] = transactionCache[keyType] || {};
+        mutations[keyType] = mutations[keyType] || {};
+        // Separate deletions from updates for batch processing
+        const deletionKeys = [];
+        const updateKeys = [];
+        for (const keyId in keyData) {
+            if (keyData[keyId] === null) {
+                deletionKeys.push(keyId);
+            }
+            else {
+                updateKeys.push(keyId);
+            }
+        }
+        // Process updates first (no validation needed)
+        for (const keyId of updateKeys) {
+            if (transactionCache[keyType]) {
+                transactionCache[keyType][keyId] = keyData[keyId];
+            }
+            if (mutations[keyType]) {
+                mutations[keyType][keyId] = keyData[keyId];
+            }
+        }
+        // Process deletions with validation
+        if (deletionKeys.length === 0)
+            return;
+        if (isInTransaction) {
+            // In transaction, only allow deletion if key exists in cache
+            for (const keyId of deletionKeys) {
+                if (transactionCache[keyType]) {
+                    transactionCache[keyType][keyId] = null;
+                    if (mutations[keyType]) {
+                        // Mark for deletion in mutations
+                        mutations[keyType][keyId] = null;
+                    }
+                }
+                else {
+                    logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`);
+                }
+            }
+            return;
+        }
+        // Outside transaction, batch validate all deletions
+        if (!state)
+            return;
+        const existingKeys = await state.get(keyType, deletionKeys);
+        for (const keyId of deletionKeys) {
+            if (existingKeys[keyId]) {
+                if (transactionCache[keyType])
+                    transactionCache[keyType][keyId] = null;
+                if (mutations[keyType])
+                    mutations[keyType][keyId] = null;
+            }
+            else {
+                logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
+            }
+        }
+    });
+}
+/**
+ * Handles normal key operations for transactions
+ */
+function handleNormalKeyOperations(data, key, transactionCache, mutations) {
+    Object.assign(transactionCache[key], data[key]);
+    mutations[key] = mutations[key] || {};
+    Object.assign(mutations[key], data[key]);
+}
+/**
+ * Process pre-key deletions with validation
+ */
+async function processPreKeyDeletions(data, keyType, state, logger) {
+    const mutex = getPreKeyMutex(keyType);
+    await mutex.runExclusive(async () => {
+        const keyData = data[keyType];
+        if (!keyData)
+            return;
+        // Validate deletions
+        for (const keyId in keyData) {
+            if (keyData[keyId] === null) {
+                const existingKeys = await state.get(keyType, [keyId]);
+                if (!existingKeys[keyId]) {
+                    logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
+                    if (data[keyType])
+                        delete data[keyType][keyId];
+                }
+            }
+        }
+    });
+}
+/**
+ * Executes a function with mutexes acquired for given key types
+ * Uses async-mutex's runExclusive with efficient batching
+ */
+async function withMutexes(keyTypes, getKeyTypeMutex, fn) {
+    if (keyTypes.length === 0) {
+        return fn();
+    }
+    if (keyTypes.length === 1) {
+        return getKeyTypeMutex(keyTypes[0]).runExclusive(fn);
+    }
+    // For multiple mutexes, sort by key type to prevent deadlocks
+    // Then acquire all mutexes in order using Promise.all for better efficiency
+    const sortedKeyTypes = [...keyTypes].sort();
+    const mutexes = sortedKeyTypes.map(getKeyTypeMutex);
+    // Acquire all mutexes in order to prevent deadlocks
+    const releases = [];
+    try {
+        for (const mutex of mutexes) {
+            releases.push(await mutex.acquire());
+        }
+        return await fn();
+    }
+    finally {
+        // Release in reverse order
+        while (releases.length > 0) {
+            const release = releases.pop();
+            if (release)
+                release();
+        }
+    }
+}
 /**
  * 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
@@ -83,24 +229,116 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
     let dbQueriesInTransaction = 0;
     let transactionCache = {};
     let mutations = {};
+    // LRU Cache to hold mutexes for different key types
+    const mutexCache = new lru_cache_1.LRUCache({
+        ttl: 60 * 60 * 1000, // 1 hour
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
     let transactionsInProgress = 0;
+    function getKeyTypeMutex(type) {
+        return getMutex(`keytype:${type}`);
+    }
+    function getSenderKeyMutex(senderKeyName) {
+        return getMutex(`senderkey:${senderKeyName}`);
+    }
+    function getTransactionMutex(key) {
+        return getMutex(`transaction:${key}`);
+    }
+    // Get or create a mutex for a specific key name
+    function getMutex(key) {
+        let mutex = mutexCache.get(key);
+        if (!mutex) {
+            mutex = new async_mutex_1.Mutex();
+            mutexCache.set(key, mutex);
+            logger.info({ key }, 'created new mutex');
+        }
+        return mutex;
+    }
+    // Sender key operations with proper mutex sequencing
+    function queueSenderKeyOperation(senderKeyName, operation) {
+        return getSenderKeyMutex(senderKeyName).runExclusive(operation);
+    }
+    // Check if we are currently in a transaction
+    function isInTransaction() {
+        return transactionsInProgress > 0;
+    }
+    // Helper function to handle transaction commit with retries
+    async function commitTransaction() {
+        if (!Object.keys(mutations).length) {
+            logger.trace('no mutations in transaction');
+            return;
+        }
+        logger.trace('committing transaction');
+        let tries = maxCommitRetries;
+        while (tries > 0) {
+            tries -= 1;
+            try {
+                await state.set(mutations);
+                logger.trace({ dbQueriesInTransaction }, 'committed transaction');
+                return;
+            }
+            catch (error) {
+                logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
+                if (tries > 0) {
+                    await (0, generics_1.delay)(delayBetweenTriesMs);
+                }
+            }
+        }
+    }
+    // Helper function to clean up transaction state
+    function cleanupTransactionState() {
+        transactionsInProgress -= 1;
+        if (transactionsInProgress === 0) {
+            transactionCache = {};
+            mutations = {};
+            dbQueriesInTransaction = 0;
+        }
+    }
+    // Helper function to execute work within transaction
+    async function executeTransactionWork(work) {
+        const result = await work();
+        // commit if this is the outermost transaction
+        if (transactionsInProgress === 1) {
+            await commitTransaction();
+        }
+        return result;
+    }
     return {
         get: async (type, ids) => {
             if (isInTransaction()) {
                 const dict = transactionCache[type];
-                const idsRequiringFetch = dict
-                    ? ids.filter(item => typeof dict[item] === 'undefined')
-                    : ids;
+                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);
+                    // Use per-sender-key queue for sender-key operations when possible
+                    if (type === 'sender-key') {
+                        logger.info({ idsRequiringFetch }, 'processing sender keys in transaction');
+                        // For sender keys, process each one with queued operations to maintain serialization
+                        for (const senderKeyName of idsRequiringFetch) {
+                            await queueSenderKeyOperation(senderKeyName, async () => {
+                                logger.info({ senderKeyName }, 'fetching sender key in transaction');
+                                const result = await state.get(type, [senderKeyName]);
+                                // Update transaction cache
+                                transactionCache[type] || (transactionCache[type] = {});
+                                Object.assign(transactionCache[type], result);
+                                logger.info({ senderKeyName, hasResult: !!result[senderKeyName] }, 'sender key fetch complete');
+                            });
+                        }
+                    }
+                    else {
+                        // Use runExclusive for cleaner mutex handling
+                        await getKeyTypeMutex(type).runExclusive(async () => {
+                            const result = await state.get(type, idsRequiringFetch);
+                            // Update transaction cache
+                            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];
+                    const value = transactionCache[type]?.[id];
                     if (value) {
                         dict[id] = value;
                     }
@@ -108,71 +346,115 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                 }, {});
             }
             else {
-                return state.get(type, ids);
+                // Not in transaction, fetch directly with queue protection
+                if (type === 'sender-key') {
+                    // For sender keys, use individual queues to maintain per-key serialization
+                    const results = {};
+                    for (const senderKeyName of ids) {
+                        const result = await queueSenderKeyOperation(senderKeyName, async () => await state.get(type, [senderKeyName]));
+                        Object.assign(results, result);
+                    }
+                    return results;
+                }
+                else {
+                    return await getKeyTypeMutex(type).runExclusive(() => state.get(type, ids));
+                }
             }
         },
-        set: data => {
+        set: async (data) => {
             if (isInTransaction()) {
                 logger.trace({ types: Object.keys(data) }, 'caching in transaction');
-                for (const key in data) {
+                for (const key_ in data) {
+                    const key = key_;
                     transactionCache[key] = transactionCache[key] || {};
-                    Object.assign(transactionCache[key], data[key]);
-                    mutations[key] = mutations[key] || {};
-                    Object.assign(mutations[key], data[key]);
+                    // Special handling for pre-keys and signed-pre-keys
+                    if (key === 'pre-key') {
+                        await handlePreKeyOperations(data, key, transactionCache, mutations, logger, true);
+                    }
+                    else {
+                        // Normal handling for other key types
+                        handleNormalKeyOperations(data, key, transactionCache, mutations);
+                    }
                 }
             }
             else {
-                return state.set(data);
+                // Not in transaction, apply directly with mutex protection
+                const hasSenderKeys = 'sender-key' in data;
+                const senderKeyNames = hasSenderKeys ? Object.keys(data['sender-key'] || {}) : [];
+                if (hasSenderKeys) {
+                    logger.info({ senderKeyNames }, 'processing sender key set operations');
+                    // Handle sender key operations with per-key queues
+                    for (const senderKeyName of senderKeyNames) {
+                        await queueSenderKeyOperation(senderKeyName, async () => {
+                            // Create data subset for this specific sender key
+                            const senderKeyData = {
+                                'sender-key': {
+                                    [senderKeyName]: data['sender-key'][senderKeyName]
+                                }
+                            };
+                            logger.trace({ senderKeyName }, 'storing sender key');
+                            // Apply changes to the store
+                            await state.set(senderKeyData);
+                            logger.trace({ senderKeyName }, 'sender key stored');
+                        });
+                    }
+                    // Handle any non-sender-key data with regular mutexes
+                    const nonSenderKeyData = { ...data };
+                    delete nonSenderKeyData['sender-key'];
+                    if (Object.keys(nonSenderKeyData).length > 0) {
+                        await withMutexes(Object.keys(nonSenderKeyData), getKeyTypeMutex, async () => {
+                            // Process pre-keys and signed-pre-keys separately with specialized mutexes
+                            for (const key_ in nonSenderKeyData) {
+                                const keyType = key_;
+                                if (keyType === 'pre-key') {
+                                    await processPreKeyDeletions(nonSenderKeyData, keyType, state, logger);
+                                }
+                            }
+                            // Apply changes to the store
+                            await state.set(nonSenderKeyData);
+                        });
+                    }
+                }
+                else {
+                    // No sender keys - use original logic
+                    await withMutexes(Object.keys(data), getKeyTypeMutex, async () => {
+                        // Process pre-keys and signed-pre-keys separately with specialized mutexes
+                        for (const key_ in data) {
+                            const keyType = key_;
+                            if (keyType === 'pre-key') {
+                                await processPreKeyDeletions(data, keyType, state, logger);
+                            }
+                        }
+                        // Apply changes to the store
+                        await state.set(data);
+                    });
+                }
             }
         },
         isInTransaction,
-        async transaction(work) {
-            let result;
-            transactionsInProgress += 1;
-            if (transactionsInProgress === 1) {
-                logger.trace('entering transaction');
-            }
+        async transaction(work, key) {
+            const releaseTxMutex = await getTransactionMutex(key).acquire();
             try {
-                result = await work();
-                // commit if this is the outermost transaction
+                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);
-                            }
-                        }
-                    }
-                    else {
-                        logger.trace('no mutations in transaction');
-                    }
+                    logger.trace('entering transaction');
                 }
-            }
-            finally {
-                transactionsInProgress -= 1;
-                if (transactionsInProgress === 0) {
-                    transactionCache = {};
-                    mutations = {};
-                    dbQueriesInTransaction = 0;
+                // Release the transaction mutex now that we've updated the counter
+                // This allows other transactions to start preparing
+                releaseTxMutex();
+                try {
+                    return await executeTransactionWork(work);
+                }
+                finally {
+                    cleanupTransactionState();
                 }
             }
-            return result;
+            catch (error) {
+                releaseTxMutex();
+                throw error;
+            }
         }
     };
-    function isInTransaction() {
-        return transactionsInProgress > 0;
-    }
 };
 exports.addTransactionCapability = addTransactionCapability;
 const initAuthCreds = () => {
@@ -191,16 +473,10 @@ const initAuthCreds = () => {
         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,
         lastPropHash: undefined,
-        routingInfo: undefined,
+        routingInfo: undefined
     };
 };
 exports.initAuthCreds = initAuthCreds;

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

@@ -50,7 +50,7 @@ const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
             if (line) {
                 const { event, data } = JSON.parse(line);
                 ev.emit(event, data);
-                delayIntervalMs && await (0, generics_1.delay)(delayIntervalMs);
+                delayIntervalMs && (await (0, generics_1.delay)(delayIntervalMs));
             }
         }
         fileStream.close();

package/lib/Utils/business.d.ts

@@ -1,5 +1,5 @@
-import { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate, WAMediaUpload, WAMediaUploadFunction } from '../Types';
-import { BinaryNode } from '../WABinary';
+import type { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate, WAMediaUpload, WAMediaUploadFunction } from '../Types';
+import { type BinaryNode } from '../WABinary';
 export declare const parseCatalogNode: (node: BinaryNode) => {
     products: Product[];
     nextPageCursor: string | undefined;

package/lib/Utils/business.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadingNecessaryImages = exports.uploadingNecessaryImagesOfProduct = exports.parseProductNode = exports.toProductNode = exports.parseOrderDetailsNode = exports.parseCollectionsNode = exports.parseCatalogNode = void 0;
+exports.uploadingNecessaryImages = exports.parseProductNode = exports.toProductNode = exports.parseOrderDetailsNode = exports.parseCollectionsNode = exports.parseCatalogNode = void 0;
+exports.uploadingNecessaryImagesOfProduct = uploadingNecessaryImagesOfProduct;
 const boom_1 = require("@hapi/boom");
 const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
 const WABinary_1 = require("../WABinary");
+const generics_1 = require("./generics");
 const messages_media_1 = require("./messages-media");
 const parseCatalogNode = (node) => {
     const catalogNode = (0, WABinary_1.getBinaryNodeChild)(node, 'product_catalog');
@@ -11,9 +16,7 @@ const parseCatalogNode = (node) => {
     const paging = (0, WABinary_1.getBinaryNodeChild)(catalogNode, 'paging');
     return {
         products,
-        nextPageCursor: paging
-            ? (0, WABinary_1.getBinaryNodeChildString)(paging, 'after')
-            : undefined
+        nextPageCursor: paging ? (0, WABinary_1.getBinaryNodeChildString)(paging, 'after') : undefined
     };
 };
 exports.parseCatalogNode = parseCatalogNode;
@@ -52,7 +55,7 @@ const parseOrderDetailsNode = (node) => {
     const orderDetails = {
         price: {
             total: +(0, WABinary_1.getBinaryNodeChildString)(priceNode, 'total'),
-            currency: (0, WABinary_1.getBinaryNodeChildString)(priceNode, 'currency'),
+            currency: (0, WABinary_1.getBinaryNodeChildString)(priceNode, 'currency')
         },
         products
     };
@@ -164,7 +167,7 @@ const parseProductNode = (productNode) => {
         id,
         imageUrls: parseImageUrls(mediaNode),
         reviewStatus: {
-            whatsapp: (0, WABinary_1.getBinaryNodeChildString)(statusInfoNode, 'status'),
+            whatsapp: (0, WABinary_1.getBinaryNodeChildString)(statusInfoNode, 'status')
         },
         availability: 'in stock',
         name: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'name'),
@@ -173,7 +176,7 @@ const parseProductNode = (productNode) => {
         description: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'description'),
         price: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'price'),
         currency: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'currency'),
-        isHidden,
+        isHidden
     };
     return product;
 };
@@ -184,11 +187,12 @@ exports.parseProductNode = parseProductNode;
 async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
     product = {
         ...product,
-        images: product.images ? await (0, exports.uploadingNecessaryImages)(product.images, waUploadToServer, timeoutMs) : product.images
+        images: product.images
+            ? await (0, exports.uploadingNecessaryImages)(product.images, waUploadToServer, timeoutMs)
+            : product.images
     };
     return product;
 }
-exports.uploadingNecessaryImagesOfProduct = uploadingNecessaryImagesOfProduct;
 /**
  * Uploads images not already uploaded to WA's servers
  */
@@ -202,17 +206,19 @@ const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 30
         }
         const { stream } = await (0, messages_media_1.getStream)(img);
         const hasher = (0, crypto_1.createHash)('sha256');
-        const contentBlocks = [];
+        const filePath = (0, path_1.join)((0, os_1.tmpdir)(), 'img' + (0, generics_1.generateMessageIDV2)());
+        const encFileWriteStream = (0, fs_1.createWriteStream)(filePath);
         for await (const block of stream) {
             hasher.update(block);
-            contentBlocks.push(block);
+            encFileWriteStream.write(block);
         }
         const sha = hasher.digest('base64');
-        const { directPath } = await waUploadToServer((0, messages_media_1.toReadable)(Buffer.concat(contentBlocks)), {
+        const { directPath } = await waUploadToServer(filePath, {
             mediaType: 'product-catalog-image',
             fileEncSha256B64: sha,
             timeoutMs
         });
+        await fs_1.promises.unlink(filePath).catch(err => console.log('Error deleting temp file ', err));
         return { url: (0, messages_media_1.getUrlFromDirectPath)(directPath) };
     }));
     return results;
@@ -229,6 +235,6 @@ const parseStatusInfo = (mediaNode) => {
     const node = (0, WABinary_1.getBinaryNodeChild)(mediaNode, 'status_info');
     return {
         status: (0, WABinary_1.getBinaryNodeChildString)(node, 'status'),
-        canAppeal: (0, WABinary_1.getBinaryNodeChildString)(node, 'can_appeal') === 'true',
+        canAppeal: (0, WABinary_1.getBinaryNodeChildString)(node, 'can_appeal') === 'true'
     };
 };