asepxyz12 1.0.0

package/lib/Types/Newsletter.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const XWAPaths = {
+    CREATE: "xwa2_newsletter_create",
+    SUBSCRIBERS: "xwa2_newsletter_subscribers",
+    VIEW: "xwa2_newsletter_view",
+    METADATA: "xwa2_newsletter",
+    UPDATE: "xwa2_newsletter_update",
+    ADMIN_COUNT: "xwa2_newsletter_admin",
+    MUTE_V2: "xwa2_newsletter_mute_v2",
+    UNMUTE_V2: "xwa2_newsletter_unmute_v2",
+    FOLLOW: "xwa2_newsletter_follow",
+    UNFOLLOW: "xwa2_newsletter_unfollow",
+    CHANGE_OWNER: "xwa2_newsletter_change_owner",
+    DEMOTE: "xwa2_newsletter_demote",
+    DELETE_V2: "xwa2_newsletter_delete_v2",
+};
+const QueryIds = {
+    CREATE: "8823471724422422",
+    UPDATE_METADATA: "24250201037901610",
+    METADATA: "6563316087068696",
+    SUBSCRIBERS: "9783111038412085",
+    FOLLOW: "7871414976211147",
+    UNFOLLOW: "7238632346214362",
+    MUTE: "29766401636284406",
+    UNMUTE: "9864994326891137",
+    ADMIN_COUNT: "7130823597031706",
+    CHANGE_OWNER: "7341777602580933",
+    DEMOTE: "6551828931592903",
+    DELETE: "30062808666639665",
+};
+module.exports = { XWAPaths: XWAPaths, QueryIds: QueryIds };

package/lib/Types/Product.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Signal.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Socket.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/State.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SyncState = {
+    Connecting: 0,
+    AwaitingInitialSync: 1,
+    Syncing: 2,
+    Online: 3,
+};
+module.exports = { SyncState: SyncState };

package/lib/Types/USync.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/index.js

@@ -0,0 +1,60 @@
+"use strict";
+const __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              let 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];
+          });
+const __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 = null;
+__exportStar(require("./Auth"), exports);
+__exportStar(require("./Bussines"), exports);
+__exportStar(require("./Chat"), exports);
+__exportStar(require("./Contact"), exports);
+__exportStar(require("./GroupMetadata"), exports);
+__exportStar(require("./State"), exports);
+__exportStar(require("./MexUpdates"), exports);
+__exportStar(require("./Message"), exports);
+__exportStar(require("./Newsletter"), exports);
+__exportStar(require("./Mex"), exports);
+__exportStar(require("./Socket"), exports);
+__exportStar(require("./Events"), exports);
+__exportStar(require("./Product"), exports);
+__exportStar(require("./Call"), exports);
+__exportStar(require("./Signal"), exports);
+const DisconnectReason = {
+    connectionClosed: 428,
+    connectionLost: 408,
+    connectionReplaced: 440,
+    timedOut: 408,
+    loggedOut: 401,
+    badSession: 500,
+    restartRequired: 515,
+    multideviceMismatch: 411,
+    forbidden: 403,
+    unavailableService: 503,
+};
+exports.DisconnectReason = DisconnectReason;

package/lib/Utils/auth-utils.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { randomBytes: randomBytes } = require("crypto");
+const { default: PQueue } = require("p-queue");
+const { default: NodeCache } = require("@cacheable/node-cache");
+const { DEFAULT_CACHE_TTLS: DEFAULT_CACHE_TTLS } = require("../Defaults/constants");
+const { AsyncLocalStorage: AsyncLocalStorage } = require("async_hooks");
+const { LRUCache: LRUCache } = require("lru-cache");
+const { Mutex: Mutex } = require("async-mutex");
+const { Curve: Curve, signedKeyPair: signedKeyPair } = require("./crypto");
+const { delay: delay, generateRegistrationId: generateRegistrationId } = require("./generics");
+const { PreKeyManager: PreKeyManager } = require("./pre-key-manager");
+function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache =
+        _cache ||
+        new NodeCache({
+            stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+            useClones: false,
+            deleteOnExpire: true,
+        });
+    const cacheMutex = new 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 = 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) {
+            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: keys }, "updated cache");
+                await store.set(data);
+            });
+        },
+        async clear() {
+            await cache.flushAll();
+            await store.clear?.call(store);
+        },
+    };
+}
+const addTransactionCapability = (
+    state,
+    logger,
+    { maxCommitRetries: maxCommitRetries, delayBetweenTriesMs: delayBetweenTriesMs }
+) => {
+    const txStorage = new AsyncLocalStorage();
+    const keyQueues = new Map();
+    const txMutexes = new Map();
+    const txMutexRefCounts = new Map();
+    const preKeyManager = new PreKeyManager(state, logger);
+    function getQueue(key) {
+        if (!keyQueues.has(key)) {
+            keyQueues.set(key, new PQueue({ concurrency: 1 }));
+        }
+        return keyQueues.get(key);
+    }
+    function getTxMutex(key) {
+        if (!txMutexes.has(key)) {
+            txMutexes.set(key, new 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 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: 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: 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: error }, "transaction failed, rolling back");
+                        throw error;
+                    }
+                });
+            } finally {
+                releaseTxMutexRef(key);
+            }
+        },
+    };
+};
+const initAuthCreds = () => {
+    const identityKey = Curve.generateKeyPair();
+    return {
+        noiseKey: Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: signedKeyPair(identityKey, 1),
+        registrationId: generateRegistrationId(),
+        advSecretKey: randomBytes(32).toString("base64"),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: { unarchiveChats: false },
+        registered: false,
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+        additionalData: undefined,
+    };
+};
+module.exports = {
+    makeCacheableSignalKeyStore: makeCacheableSignalKeyStore,
+    addTransactionCapability: addTransactionCapability,
+    initAuthCreds: initAuthCreds,
+};

package/lib/Utils/browser-utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { platform: platform, release: release } = require("os");
+const { proto: proto } = require("../../WAProto");
+const PLATFORM_MAP = {
+    aix: "AIX",
+    darwin: "Mac OS",
+    win32: "Windows",
+    android: "Android",
+    freebsd: "FreeBSD",
+    openbsd: "OpenBSD",
+    sunos: "Solaris",
+    linux: undefined,
+    haiku: undefined,
+    cygwin: undefined,
+    netbsd: undefined,
+};
+const Browsers = {
+    ubuntu: (browser) => ["Ubuntu", browser, "22.04.4"],
+    macOS: (browser) => ["Mac OS", browser, "14.4.1"],
+    baileys: (browser) => ["Baileys", browser, "6.5.0"],
+    windows: (browser) => ["Windows", browser, "10.0.22631"],
+    appropriate: (browser) => [PLATFORM_MAP[platform()] || "Ubuntu", browser, release()],
+};
+const getPlatformId = (browser) => {
+    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+    return platformType ? platformType.toString() : "1";
+};
+module.exports = { Browsers: Browsers, getPlatformId: getPlatformId };

package/lib/Utils/business.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Boom: Boom } = require("@hapi/boom");
+const { createHash: createHash } = require("crypto");
+const { join: join } = require("path");
+const { tmpdir: tmpdir } = require("os");
+const { promises: promises, createWriteStream: createWriteStream } = require("fs");
+const {
+    getBinaryNodeChild: getBinaryNodeChild,
+    getBinaryNodeChildren: getBinaryNodeChildren,
+    getBinaryNodeChildString: getBinaryNodeChildString,
+} = require("../WABinary");
+const {
+    getStream: getStream,
+    getUrlFromDirectPath: getUrlFromDirectPath,
+} = require("./messages-media");
+const { generateMessageID: generateMessageID } = require("./generics");
+const parseCatalogNode = (node) => {
+    const catalogNode = getBinaryNodeChild(node, "product_catalog");
+    const products = getBinaryNodeChildren(catalogNode, "product").map(parseProductNode);
+    const paging = getBinaryNodeChild(catalogNode, "paging");
+    return {
+        products: products,
+        nextPageCursor: paging ? getBinaryNodeChildString(paging, "after") : undefined,
+    };
+};
+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: id,
+                name: name,
+                products: products,
+                status: parseStatusInfo(collectionNode),
+            };
+        }
+    );
+    return { collections: collections };
+};
+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: products,
+    };
+    return orderDetails;
+};
+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: attrs, content: content };
+    return node;
+};
+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: 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: isHidden,
+    };
+    return product;
+};
+async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 3e4) {
+    product = {
+        ...product,
+        images: product.images
+            ? await uploadingNecessaryImages(product.images, waUploadToServer, timeoutMs)
+            : product.images,
+    };
+    return product;
+}
+const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 3e4) => {
+    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: url };
+                }
+            }
+            const { stream: stream } = await getStream(img);
+            const hasher = createHash("sha256");
+            const filePath = join(tmpdir(), "img" + generateMessageID());
+            const encFileWriteStream = createWriteStream(filePath);
+            for await (const block of stream) {
+                hasher.update(block);
+                encFileWriteStream.write(block);
+            }
+            const sha = hasher.digest("base64");
+            const { directPath: directPath } = await waUploadToServer(filePath, {
+                mediaType: "product-catalog-image",
+                fileEncSha256B64: sha,
+                timeoutMs: timeoutMs,
+            });
+            await promises
+                .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",
+    };
+};
+module.exports = {
+    parseCatalogNode: parseCatalogNode,
+    parseCollectionsNode: parseCollectionsNode,
+    parseOrderDetailsNode: parseOrderDetailsNode,
+    toProductNode: toProductNode,
+    parseProductNode: parseProductNode,
+    uploadingNecessaryImagesOfProduct: uploadingNecessaryImagesOfProduct,
+    uploadingNecessaryImages: uploadingNecessaryImages,
+};