@badzz88/baileys 8.5.4 → 8.5.6

package/src/Utils/auth-utils.js

@@ -0,0 +1,254 @@
+'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) {
+    const cache = _cache ||
+        new node_cache_1.default({
+            stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+            useClones: false,
+            deleteOnExpire: true
+        });
+    const cacheMutex = new async_mutex_1.Mutex();
+    function getUniqueId(type, id) {
+        return `${type}.${id}`;
+    }
+    return {
+        async get(type, ids) {
+            return cacheMutex.runExclusive(async () => {
+                const data = {};
+                const idsToFetch = [];
+                for (const id of ids) {
+                    const item = await 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;
+                            await cache.set(getUniqueId(type, id), item);
+                        }
+                    }
+                }
+                return data;
+            });
+        },
+        async set(data) {
+            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);
+            });
+        },
+        async clear() {
+            await cache.flushAll();
+            await store.clear?.();
+        }
+    };
+}
+const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    const txStorage = new async_hooks_1.AsyncLocalStorage();
+    const keyQueues = new Map();
+    const txMutexes = new Map();
+    const txMutexRefCounts = new Map();
+    const preKeyManager = new pre_key_manager_1.PreKeyManager(state, logger);
+    function getQueue(key) {
+        if (!keyQueues.has(key)) {
+            keyQueues.set(key, new p_queue_1.default({ concurrency: 1 }));
+        }
+        return keyQueues.get(key);
+    }
+    function getTxMutex(key) {
+        if (!txMutexes.has(key)) {
+            txMutexes.set(key, new async_mutex_1.Mutex());
+            txMutexRefCounts.set(key, 0);
+        }
+        return txMutexes.get(key);
+    }
+    function acquireTxMutexRef(key) {
+        const count = txMutexRefCounts.get(key) ?? 0;
+        txMutexRefCounts.set(key, count + 1);
+    }
+    function releaseTxMutexRef(key) {
+        const count = (txMutexRefCounts.get(key) ?? 1) - 1;
+        txMutexRefCounts.set(key, count);
+        if (count <= 0) {
+            const mutex = txMutexes.get(key);
+            if (mutex && !mutex.isLocked()) {
+                txMutexes.delete(key);
+                txMutexRefCounts.delete(key);
+            }
+        }
+    }
+    function isInTransaction() {
+        return !!txStorage.getStore();
+    }
+    async function commitWithRetry(mutations) {
+        if (Object.keys(mutations).length === 0) {
+            logger.trace('no mutations in transaction');
+            return;
+        }
+        logger.trace('committing transaction');
+        for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
+            try {
+                await state.set(mutations);
+                logger.trace({ mutationCount: Object.keys(mutations).length }, 'committed transaction');
+                return;
+            }
+            catch (error) {
+                const retriesLeft = maxCommitRetries - attempt - 1;
+                logger.warn(`failed to commit mutations, retries left=${retriesLeft}`);
+                if (retriesLeft === 0) {
+                    throw error;
+                }
+                await (0, generics_1.delay)(delayBetweenTriesMs);
+            }
+        }
+    }
+    return {
+        get: async (type, ids) => {
+            const ctx = txStorage.getStore();
+            if (!ctx) {
+                return state.get(type, ids);
+            }
+            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));
+                ctx.cache[type] = ctx.cache[type] || {};
+                Object.assign(ctx.cache[type], fetched);
+            }
+            const result = {};
+            for (const id of ids) {
+                const value = ctx.cache[type]?.[id];
+                if (value !== undefined && value !== null) {
+                    result[id] = value;
+                }
+            }
+            return result;
+        },
+        set: async (data) => {
+            const ctx = txStorage.getStore();
+            if (!ctx) {
+                const types = Object.keys(data);
+                for (const type_ of types) {
+                    const type = type_;
+                    if (type === 'pre-key') {
+                        await preKeyManager.validateDeletions(data, type);
+                    }
+                }
+                await Promise.all(types.map(type => getQueue(type).add(async () => {
+                    const typeData = { [type]: data[type] };
+                    await state.set(typeData);
+                })));
+                return;
+            }
+            logger.trace({ types: Object.keys(data) }, 'caching in transaction');
+            for (const key_ in data) {
+                const key = key_;
+                ctx.cache[key] = ctx.cache[key] || {};
+                ctx.mutations[key] = ctx.mutations[key] || {};
+                if (key === 'pre-key') {
+                    await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true);
+                }
+                else {
+                    Object.assign(ctx.cache[key], data[key]);
+                    Object.assign(ctx.mutations[key], data[key]);
+                }
+            }
+        },
+        isInTransaction,
+        transaction: async (work, key) => {
+            const existing = txStorage.getStore();
+            if (existing) {
+                logger.trace('reusing existing transaction context');
+                return work();
+            }
+            const mutex = getTxMutex(key);
+            acquireTxMutexRef(key);
+            try {
+                return await mutex.runExclusive(async () => {
+                    const ctx = {
+                        cache: {},
+                        mutations: {},
+                        dbQueries: 0
+                    };
+                    logger.trace('entering transaction');
+                    try {
+                        const result = await txStorage.run(ctx, work);
+                        await commitWithRetry(ctx.mutations);
+                        logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed');
+                        return result;
+                    }
+                    catch (error) {
+                        logger.error({ error }, 'transaction failed, rolling back');
+                        throw error;
+                    }
+                });
+            }
+            finally {
+                releaseTxMutexRef(key);
+            }
+        }
+    };
+};
+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: [],
+        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,
+        routingInfo: undefined,
+        additionalData: undefined
+    };
+};
+exports.initAuthCreds = initAuthCreds;

package/src/Utils/browser-utils.js

@@ -0,0 +1,112 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getPlatformId = exports.Browsers = void 0;
+const os_1 = require('os');
+const index_js_1 = require('../../WAProto/index.js');
+const COMPANION_PLATFORM_MAP = {
+    Chrome: '49',
+    Edge: '50',
+    Firefox: '51',
+    Opera: '53',
+    Safari: '54',
+    Brave: '1.79.112',
+    Vivaldi: '6.2.3105.58',
+    Tor: '12.5.3',
+    Yandex: '23.7.1',
+    Falkon: '22.08.3',
+    Epiphany: '44.2'
+};
+const PLATFORM_MAP = {
+    aix: 'AIX',
+    darwin: 'Mac OS',
+    win32: 'Windows',
+    android: 'Android',
+    freebsd: 'FreeBSD',
+    openbsd: 'OpenBSD',
+    sunos: 'Solaris',
+    linux: 'Linux',
+    ubuntu: 'Ubuntu',
+    ios: 'iOS',
+    baileys: 'Baileys',
+    chromeos: 'Chrome OS',
+    tizen: 'Tizen',
+    watchos: 'watchOS',
+    wearos: 'Wear OS',
+    harmonyos: 'HarmonyOS',
+    kaios: 'KaiOS',
+    smarttv: 'Smart TV',
+    raspberrypi: 'Raspberry Pi OS',
+    symbian: 'Symbian',
+    blackberry: 'Blackberry OS',
+    windowsphone: 'Windows Phone',
+    safari: 'Safari'
+};
+const PLATFORM_VERSIONS = {
+    ubuntu: '22.04.4',
+    darwin: '18.5',
+    win32: '10.0.22631',
+    android: '14.0.0',
+    freebsd: '13.2',
+    openbsd: '7.3',
+    sunos: '11',
+    linux: '6.5',
+    ios: '18.2',
+    baileys: '6.5.0',
+    chromeos: '117.0.5938.132',
+    tizen: '6.5',
+    watchos: '10.1',
+    wearos: '4.1',
+    harmonyos: '4.0.0',
+    kaios: '3.1',
+    smarttv: '23.3.1',
+    raspberrypi: '11 (Bullseye)',
+    symbian: '3',
+    blackberry: '10.3.3',
+    windowsphone: '8.1'
+};
+exports.Browsers = {
+    ubuntu: browser => {
+        return [PLATFORM_MAP['ubuntu'], browser, PLATFORM_VERSIONS['ubuntu']];
+    },
+    macOS: browser => {
+        return [PLATFORM_MAP['darwin'], browser, PLATFORM_VERSIONS['darwin']];
+    },
+    windows: browser => {
+        return [PLATFORM_MAP['win32'], browser, PLATFORM_VERSIONS['win32']];
+    },
+    linux: browser => {
+        return [PLATFORM_MAP['linux'], browser, PLATFORM_VERSIONS['linux']];
+    },
+    solaris: browser => {
+        return [PLATFORM_MAP['sunos'], browser, PLATFORM_VERSIONS['sunos']];
+    },
+    baileys: browser => {
+        return [PLATFORM_MAP['baileys'], browser, PLATFORM_VERSIONS['baileys']];
+    },
+    android: browser => {
+        return [PLATFORM_MAP['android'], browser, PLATFORM_VERSIONS['android']];
+    },
+    iOS: browser => {
+        return [PLATFORM_MAP['ios'], browser, PLATFORM_VERSIONS['ios']];
+    },
+    kaiOS: browser => {
+        return [PLATFORM_MAP['kaios'], browser, PLATFORM_VERSIONS['kaios']];
+    },
+    chromeOS: browser => {
+        return [PLATFORM_MAP['chromeos'], browser, PLATFORM_VERSIONS['chromeos']];
+    },
+    appropriate: browser => {
+        const platform = os_1.platform();
+        const platformName = PLATFORM_MAP[platform] || 'Unknown OS';
+        return [platformName, browser, PLATFORM_VERSIONS[platform] || 'latest'];
+    },
+    custom: (platform, browser, version) => {
+        const platformName = PLATFORM_MAP[platform.toLowerCase()] || platform;
+        return [platformName, browser, version || PLATFORM_VERSIONS[platform] || 'latest'];
+    }
+};
+const getPlatformId = browser => {
+    const platformType = index_js_1.proto.DeviceProps.PlatformType[browser.toUpperCase()];
+    return platformType ? platformType.toString() : '1';
+};
+exports.getPlatformId = getPlatformId;

package/src/Utils/business.js

@@ -0,0 +1,240 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+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');
+    const products = (0, WABinary_1.getBinaryNodeChildren)(catalogNode, 'product').map(exports.parseProductNode);
+    const paging = (0, WABinary_1.getBinaryNodeChild)(catalogNode, 'paging');
+    return {
+        products,
+        nextPageCursor: paging ? (0, WABinary_1.getBinaryNodeChildString)(paging, 'after') : undefined
+    };
+};
+exports.parseCatalogNode = parseCatalogNode;
+const parseCollectionsNode = node => {
+    const collectionsNode = (0, WABinary_1.getBinaryNodeChild)(node, 'collections');
+    const collections = (0, WABinary_1.getBinaryNodeChildren)(collectionsNode, 'collection').map(collectionNode => {
+        const id = (0, WABinary_1.getBinaryNodeChildString)(collectionNode, 'id');
+        const name = (0, WABinary_1.getBinaryNodeChildString)(collectionNode, 'name');
+        const products = (0, WABinary_1.getBinaryNodeChildren)(collectionNode, 'product').map(exports.parseProductNode);
+        return {
+            id,
+            name,
+            products,
+            status: parseStatusInfo(collectionNode)
+        };
+    });
+    return {
+        collections
+    };
+};
+exports.parseCollectionsNode = parseCollectionsNode;
+const parseOrderDetailsNode = node => {
+    const orderNode = (0, WABinary_1.getBinaryNodeChild)(node, 'order');
+    const products = (0, WABinary_1.getBinaryNodeChildren)(orderNode, 'product').map(productNode => {
+        const imageNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'image');
+        return {
+            id: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'id'),
+            name: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'name'),
+            imageUrl: (0, WABinary_1.getBinaryNodeChildString)(imageNode, 'url'),
+            price: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'price'),
+            currency: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'currency'),
+            quantity: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'quantity')
+        };
+    });
+    const priceNode = (0, WABinary_1.getBinaryNodeChild)(orderNode, 'price');
+    const orderDetails = {
+        price: {
+            total: +(0, WABinary_1.getBinaryNodeChildString)(priceNode, 'total'),
+            currency: (0, WABinary_1.getBinaryNodeChildString)(priceNode, 'currency')
+        },
+        products
+    };
+    return orderDetails;
+};
+exports.parseOrderDetailsNode = parseOrderDetailsNode;
+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_1.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;
+};
+exports.toProductNode = toProductNode;
+const parseProductNode = productNode => {
+    const isHidden = productNode.attrs.is_hidden === 'true';
+    const id = (0, WABinary_1.getBinaryNodeChildString)(productNode, 'id');
+    const mediaNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'media');
+    const statusInfoNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'status_info');
+    const product = {
+        id,
+        imageUrls: parseImageUrls(mediaNode),
+        reviewStatus: {
+            whatsapp: (0, WABinary_1.getBinaryNodeChildString)(statusInfoNode, 'status')
+        },
+        availability: 'in stock',
+        name: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'name'),
+        retailerId: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'retailer_id'),
+        url: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'url'),
+        description: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'description'),
+        price: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'price'),
+        currency: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'currency'),
+        isHidden
+    };
+    return product;
+};
+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
+    };
+    return product;
+}
+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 (0, messages_media_1.getStream)(img);
+        const hasher = (0, crypto_1.createHash)('sha256');
+        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);
+            encFileWriteStream.write(block);
+        }
+        const sha = hasher.digest('base64');
+        const { directPath } = await waUploadToServer(filePath, {
+            mediaType: 'product-catalog-image',
+            fileEncSha256B64: sha,
+            timeoutMs
+        });
+        await fs_1.promises.unlink(filePath).catch(() => { });
+        return { url: (0, messages_media_1.getUrlFromDirectPath)(directPath) };
+    }));
+    return results;
+};
+exports.uploadingNecessaryImages = uploadingNecessaryImages;
+const parseImageUrls = mediaNode => {
+    const imgNode = (0, WABinary_1.getBinaryNodeChild)(mediaNode, 'image');
+    return {
+        requested: (0, WABinary_1.getBinaryNodeChildString)(imgNode, 'request_image_url'),
+        original: (0, WABinary_1.getBinaryNodeChildString)(imgNode, 'original_image_url')
+    };
+};
+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'
+    };
+};