violetics 7.0.0-alpha

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIDMappingStore = void 0;
+const lru_cache_1 = require("lru-cache");
+const jid_utils_1 = require("../WABinary/jid-utils");
+
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new lru_cache_1.LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        });
+        this.inflightLIDLookups = new Map();
+        this.inflightPNLookups = new Map();
+        this.keys = keys;
+        this.logger = logger;
+        this.pnToLIDFunc = pnToLIDFunc;
+    }
+
+    async storeLIDPNMappings(pairs) {
+        const pairMap = {};
+        for (const { lid, pn } of pairs) {
+            if (!lid || !pn) continue;
+            const lidDecoded = (0, jid_utils_1.jidDecode)(lid);
+            const pnDecoded = (0, jid_utils_1.jidDecode)(pn);
+            if (!lidDecoded || !pnDecoded) continue;
+            const pnUser = pnDecoded.user;
+            const lidUser = lidDecoded.user;
+            if (!pnUser || !lidUser || typeof pnUser !== 'string' || typeof lidUser !== 'string') continue;
+            const existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (existingLidUser === lidUser) continue;
+            pairMap[pnUser] = lidUser;
+        }
+        if (Object.keys(pairMap).length === 0) return;
+        try {
+            await this.keys.transaction(async () => {
+                for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+                    await this.keys.set({
+                        'lid-mapping': {
+                            [`pn:${pnUser}`]: lidUser,
+                            [`lid:${lidUser}`]: pnUser
+                        }
+                    });
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                }
+            }, 'lid-mapping');
+        } catch (e) {
+            if (this.logger) this.logger.warn({ e }, 'failed to store LID-PN mappings');
+        }
+    }
+
+    async getLIDForPN(pn) {
+        if (!pn) return null;
+        if (this.inflightPNLookups.has(pn)) {
+            return this.inflightPNLookups.get(pn);
+        }
+        const promise = this.getLIDsForPNs([pn]).then(r => r?.[0]?.lid || null);
+        this.inflightPNLookups.set(pn, promise);
+        try {
+            return await promise;
+        } finally {
+            this.inflightPNLookups.delete(pn);
+        }
+    }
+
+    async getLIDsForPNs(pns) {
+        const usyncFetch = {};
+        const successfulPairs = {};
+        for (const pn of pns) {
+            if (!pn) continue;
+            const decoded = (0, jid_utils_1.jidDecode)(pn);
+            if (!decoded?.user) continue;
+            const pnUser = decoded.user;
+            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!lidUser) {
+                try {
+                    const stored = await this.keys.get('lid-mapping', [`pn:${pnUser}`]);
+                    lidUser = stored[`pn:${pnUser}`];
+                    if (lidUser) {
+                        this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                        this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                    } else {
+                        const device = decoded.device || 0;
+                        const normalizedPn = `${pnUser}@s.whatsapp.net`;
+                        if (!usyncFetch[normalizedPn]) {
+                            usyncFetch[normalizedPn] = [device];
+                        } else {
+                            usyncFetch[normalizedPn].push(device);
+                        }
+                        continue;
+                    }
+                } catch (e) { continue; }
+            }
+            if (typeof lidUser !== 'string' || !lidUser) continue;
+            const pnDevice = decoded.device || 0;
+            const deviceSpecificLid = `${lidUser}${pnDevice ? `:${pnDevice}` : ''}@lid`;
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn };
+        }
+        if (Object.keys(usyncFetch).length > 0) {
+            try {
+                const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+                if (result && result.length > 0) {
+                    await this.storeLIDPNMappings(result);
+                    for (const pair of result) {
+                        const pnDecoded = (0, jid_utils_1.jidDecode)(pair.pn);
+                        const pnUser = pnDecoded?.user;
+                        if (!pnUser) continue;
+                        const lidUser = (0, jid_utils_1.jidDecode)(pair.lid)?.user;
+                        if (!lidUser) continue;
+                        for (const device of (usyncFetch[pair.pn] || [])) {
+                            const deviceSpecificLid = `${lidUser}${device ? `:${device}` : ''}@lid`;
+                            const deviceSpecificPn = `${pnUser}${device ? `:${device}` : ''}@s.whatsapp.net`;
+                            successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
+                        }
+                    }
+                } else {
+                    return null;
+                }
+            } catch (e) {
+                return null;
+            }
+        }
+        return Object.values(successfulPairs);
+    }
+
+    async getPNsForLIDs(lids) {
+        const result = [];
+        const missingLids = [];
+        for (const lid of lids) {
+            if (!lid) continue;
+            const decoded = (0, jid_utils_1.jidDecode)(lid);
+            if (!decoded?.user) continue;
+            const lidUser = decoded.user;
+            const pnUser = this.mappingCache.get(`lid:${lidUser}`);
+            if (!pnUser || typeof pnUser !== 'string') {
+                missingLids.push(lidUser);
+            } else {
+                const lidDevice = decoded.device || 0;
+                const pnJid = `${pnUser}${lidDevice ? `:${lidDevice}` : ''}@s.whatsapp.net`;
+                result.push({ lid, pn: pnJid });
+            }
+        }
+        if (missingLids.length > 0) {
+            try {
+                const dbKeys = missingLids.map(l => `lid:${l}`);
+                const stored = await this.keys.get('lid-mapping', dbKeys);
+                for (const lidUser of missingLids) {
+                    const pnUser = stored[`lid:${lidUser}`];
+                    if (pnUser && typeof pnUser === 'string') {
+                        this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                        for (const lid of lids) {
+                            if (lid.startsWith(lidUser)) {
+                                const decoded = (0, jid_utils_1.jidDecode)(lid);
+                                if (decoded) {
+                                    const lidDevice = decoded.device || 0;
+                                    const pnJid = `${pnUser}${lidDevice ? `:${lidDevice}` : ''}@s.whatsapp.net`;
+                                    result.push({ lid, pn: pnJid });
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (e) {}
+        }
+        return result;
+    }
+
+    async getPNForLID(lid) {
+        if (!lid) return null;
+        if (this.inflightLIDLookups.has(lid)) {
+            return this.inflightLIDLookups.get(lid);
+        }
+        const promise = this.getPNsForLIDs([lid]).then(r => r?.[0]?.pn || null);
+        this.inflightLIDLookups.set(lid, promise);
+        try {
+            return await promise;
+        } finally {
+            this.inflightLIDLookups.delete(lid);
+        }
+    }
+}
+
+exports.LIDMappingStore = LIDMappingStore;

package/lib/Socket/Client/abstract-socket-client.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSocketClient = void 0;
+const events_1 = require("events");
+class AbstractSocketClient extends events_1.EventEmitter {
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
+}
+exports.AbstractSocketClient = AbstractSocketClient;

package/lib/Socket/Client/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract-socket-client"), exports);
+__exportStar(require("./mobile-socket-client"), exports);
+__exportStar(require("./web-socket-client"), exports);

package/lib/Socket/Client/mobile-socket-client.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileSocketClient = void 0;
+const net_1 = require("net");
+const abstract_socket_client_1 = require("./abstract-socket-client");
+class MobileSocketClient extends abstract_socket_client_1.AbstractSocketClient {
+    constructor() {
+        super(...arguments);
+        this.socket = null;
+    }
+    get isOpen() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'open';
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isClosing() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'opening';
+    }
+    async connect() {
+        var _a;
+        if (this.socket) {
+            return;
+        }
+        if (this.config.agent) {
+            throw new Error('There are not support for proxy agent for mobile connection');
+        }
+        else {
+            this.socket = (0, net_1.connect)({
+                host: this.url.hostname,
+                port: Number(this.url.port) || 443
+            });
+        }
+        this.socket.setMaxListeners(0);
+        const events = ['close', 'connect', 'data', 'drain', 'end', 'error', 'lookup', 'ready', 'timeout'];
+        for (const event of events) {
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on(event, (...args) => this.emit(event, ...args));
+        }
+        this.socket.on('data', (...args) => this.emit('message', ...args));
+        this.socket.on('ready', (...args) => this.emit('open', ...args));
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        return new Promise(resolve => {
+            this.socket.end(resolve);
+            this.socket = null;
+        });
+    }
+    send(str, cb) {
+        if (this.socket === null) {
+            return false;
+        }
+        return this.socket.write(str, undefined, cb);
+    }
+}
+exports.MobileSocketClient = MobileSocketClient;

package/lib/Socket/Client/web-socket-client.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const dns_1 = require("dns");
+const Defaults_1 = require("../../Defaults");
+const abstract_socket_client_1 = require("./abstract-socket-client");
+
+// Simple DNS cache to prevent repeated lookups when many bots reconnect at once.
+// ENOTFOUND errors are typically transient — caching the last good IP avoids them.
+const DNS_CACHE = new Map(); // hostname → { address, expires }
+const DNS_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+async function resolveWithCache(hostname) {
+    const now = Date.now();
+    const cached = DNS_CACHE.get(hostname);
+    if (cached && cached.expires > now) {
+        return cached.address;
+    }
+    return new Promise((resolve, reject) => {
+        (0, dns_1.lookup)(hostname, { family: 4 }, (err, address) => {
+            if (err) {
+                // If lookup fails but we have a stale cache entry, use it
+                if (cached) {
+                    return resolve(cached.address);
+                }
+                return reject(err);
+            }
+            DNS_CACHE.set(hostname, { address, expires: now + DNS_TTL_MS });
+            resolve(address);
+        });
+    });
+}
+
+class WebSocketClient extends abstract_socket_client_1.AbstractSocketClient {
+    constructor() {
+        super(...arguments);
+        this.socket = null;
+    }
+    get isOpen() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN;
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSED;
+    }
+    get isClosing() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSING;
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CONNECTING;
+    }
+    async connect() {
+        var _a, _b;
+        if (this.socket) {
+            return;
+        }
+        // Resolve hostname with cache to avoid ENOTFOUND on transient DNS failures
+        let connectUrl = this.url;
+        try {
+            const parsedUrl = new URL(this.url);
+            const ip = await resolveWithCache(parsedUrl.hostname);
+            // Replace hostname with resolved IP, keep original Host header for TLS SNI
+            const resolvedUrl = new URL(this.url);
+            resolvedUrl.hostname = ip;
+            connectUrl = resolvedUrl.toString();
+        }
+        catch (_c) {
+            // fallback: use original URL if DNS resolution fails entirely
+        }
+        this.socket = new ws_1.default(connectUrl, {
+            origin: Defaults_1.DEFAULT_ORIGIN,
+            headers: {
+                ...((_a = this.config.options) === null || _a === void 0 ? void 0 : _a.headers),
+                // Preserve the original hostname for TLS SNI and WA server routing
+                Host: new URL(this.url).hostname,
+            },
+            handshakeTimeout: Math.max(this.config.connectTimeoutMs, 60000),
+            timeout: Math.max(this.config.connectTimeoutMs, 60000),
+            agent: this.config.agent,
+        });
+        this.socket.setMaxListeners(0);
+        const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
+        for (const event of events) {
+            (_b = this.socket) === null || _b === void 0 ? void 0 : _b.on(event, (...args) => this.emit(event, ...args));
+        }
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        const closePromise = new Promise((resolve) => {
+            this.socket.once('close', resolve);
+        });
+        this.socket.close();
+        await closePromise;
+        this.socket = null;
+    }
+    send(str, cb) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(str, cb);
+        return Boolean(this.socket);
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/lib/Socket/business.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBusinessSocket = void 0;
+const business_1 = require("../Utils/business");
+const WABinary_1 = require("../WABinary");
+const generic_utils_1 = require("../WABinary/generic-utils");
+const messages_recv_1 = require("./messages-recv");
+const makeBusinessSocket = (config) => {
+    const sock = (0, messages_recv_1.makeMessagesRecvSocket)(config);
+    const { authState, query, waUploadToServer } = sock;
+    const getCatalog = async ({ jid, limit, cursor }) => {
+        var _a;
+        jid = jid || ((_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id);
+        jid = (0, WABinary_1.jidNormalizedUser)(jid);
+        const queryParamNodes = [
+            {
+                tag: 'limit',
+                attrs: {},
+                content: Buffer.from((limit || 10).toString())
+            },
+            {
+                tag: 'width',
+                attrs: {},
+                content: Buffer.from('100')
+            },
+            {
+                tag: 'height',
+                attrs: {},
+                content: Buffer.from('100')
+            },
+        ];
+        if (cursor) {
+            queryParamNodes.push({
+                tag: 'after',
+                attrs: {},
+                content: cursor
+            });
+        }
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'w:biz:catalog'
+            },
+            content: [
+                {
+                    tag: 'product_catalog',
+                    attrs: {
+                        jid,
+                        'allow_shop_source': 'true'
+                    },
+                    content: queryParamNodes
+                }
+            ]
+        });
+        return (0, business_1.parseCatalogNode)(result);
+    };
+    const getCollections = async (jid, limit = 51) => {
+        var _a;
+        jid = jid || ((_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id);
+        jid = (0, WABinary_1.jidNormalizedUser)(jid);
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'w:biz:catalog',
+                'smax_id': '35'
+            },
+            content: [
+                {
+                    tag: 'collections',
+                    attrs: {
+                        'biz_jid': jid,
+                    },
+                    content: [
+                        {
+                            tag: 'collection_limit',
+                            attrs: {},
+                            content: Buffer.from(limit.toString())
+                        },
+                        {
+                            tag: 'item_limit',
+                            attrs: {},
+                            content: Buffer.from(limit.toString())
+                        },
+                        {
+                            tag: 'width',
+                            attrs: {},
+                            content: Buffer.from('100')
+                        },
+                        {
+                            tag: 'height',
+                            attrs: {},
+                            content: Buffer.from('100')
+                        }
+                    ]
+                }
+            ]
+        });
+        return (0, business_1.parseCollectionsNode)(result);
+    };
+    const getOrderDetails = async (orderId, tokenBase64) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'fb:thrift_iq',
+                'smax_id': '5'
+            },
+            content: [
+                {
+                    tag: 'order',
+                    attrs: {
+                        op: 'get',
+                        id: orderId
+                    },
+                    content: [
+                        {
+                            tag: 'image_dimensions',
+                            attrs: {},
+                            content: [
+                                {
+                                    tag: 'width',
+                                    attrs: {},
+                                    content: Buffer.from('100')
+                                },
+                                {
+                                    tag: 'height',
+                                    attrs: {},
+                                    content: Buffer.from('100')
+                                }
+                            ]
+                        },
+                        {
+                            tag: 'token',
+                            attrs: {},
+                            content: Buffer.from(tokenBase64)
+                        }
+                    ]
+                }
+            ]
+        });
+        return (0, business_1.parseOrderDetailsNode)(result);
+    };
+    const productUpdate = async (productId, update) => {
+        update = await (0, business_1.uploadingNecessaryImagesOfProduct)(update, waUploadToServer);
+        const editNode = (0, business_1.toProductNode)(productId, update);
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'w:biz:catalog'
+            },
+            content: [
+                {
+                    tag: 'product_catalog_edit',
+                    attrs: { v: '1' },
+                    content: [
+                        editNode,
+                        {
+                            tag: 'width',
+                            attrs: {},
+                            content: '100'
+                        },
+                        {
+                            tag: 'height',
+                            attrs: {},
+                            content: '100'
+                        }
+                    ]
+                }
+            ]
+        });
+        const productCatalogEditNode = (0, generic_utils_1.getBinaryNodeChild)(result, 'product_catalog_edit');
+        const productNode = (0, generic_utils_1.getBinaryNodeChild)(productCatalogEditNode, 'product');
+        return (0, business_1.parseProductNode)(productNode);
+    };
+    const productCreate = async (create) => {
+        // ensure isHidden is defined
+        create.isHidden = !!create.isHidden;
+        create = await (0, business_1.uploadingNecessaryImagesOfProduct)(create, waUploadToServer);
+        const createNode = (0, business_1.toProductNode)(undefined, create);
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'w:biz:catalog'
+            },
+            content: [
+                {
+                    tag: 'product_catalog_add',
+                    attrs: { v: '1' },
+                    content: [
+                        createNode,
+                        {
+                            tag: 'width',
+                            attrs: {},
+                            content: '100'
+                        },
+                        {
+                            tag: 'height',
+                            attrs: {},
+                            content: '100'
+                        }
+                    ]
+                }
+            ]
+        });
+        const productCatalogAddNode = (0, generic_utils_1.getBinaryNodeChild)(result, 'product_catalog_add');
+        const productNode = (0, generic_utils_1.getBinaryNodeChild)(productCatalogAddNode, 'product');
+        return (0, business_1.parseProductNode)(productNode);
+    };
+    const productDelete = async (productIds) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'w:biz:catalog'
+            },
+            content: [
+                {
+                    tag: 'product_catalog_delete',
+                    attrs: { v: '1' },
+                    content: productIds.map(id => ({
+                        tag: 'product',
+                        attrs: {},
+                        content: [
+                            {
+                                tag: 'id',
+                                attrs: {},
+                                content: Buffer.from(id)
+                            }
+                        ]
+                    }))
+                }
+            ]
+        });
+        const productCatalogDelNode = (0, generic_utils_1.getBinaryNodeChild)(result, 'product_catalog_delete');
+        return {
+            deleted: +((productCatalogDelNode === null || productCatalogDelNode === void 0 ? void 0 : productCatalogDelNode.attrs.deleted_count) || 0)
+        };
+    };
+    return {
+        ...sock,
+        logger: config.logger,
+        getOrderDetails,
+        getCatalog,
+        getCollections,
+        productCreate,
+        productDelete,
+        productUpdate
+    };
+};
+exports.makeBusinessSocket = makeBusinessSocket;