@nerxa/socketon 0.0.0-stage → 1.21.0

package/src/WABinary/generic-utils.js

@@ -0,0 +1,214 @@
+import { Boom } from '@hapi/boom';
+import { randomBytes } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+
+const indexCache = new WeakMap();
+export const getBinaryNodeChildren = (node, childTag) => {
+    if (!node || !Array.isArray(node.content))
+        return [];
+    let index = indexCache.get(node);
+
+    if (!index) {
+        index = new Map();
+        for (const child of node.content) {
+            let arr = index.get(child.tag);
+            if (!arr)
+                index.set(child.tag, (arr = []));
+            arr.push(child);
+        }
+        indexCache.set(node, index);
+    }
+
+    return index.get(childTag) || [];
+};
+export const getBinaryNodeChild = (node, childTag) => {
+    return getBinaryNodeChildren(node, childTag)[0];
+};
+export const getAllBinaryNodeChildren = ({ content }) => {
+    if (Array.isArray(content)) {
+        return content;
+    }
+    return [];
+};
+export const getBinaryNodeChildBuffer = (node, childTag) => {
+    const child = getBinaryNodeChild(node, childTag)?.content;
+    if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
+        return child;
+    }
+};
+export const getBinaryNodeChildString = (node, childTag) => {
+    const child = getBinaryNodeChild(node, childTag)?.content;
+    if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
+        return Buffer.from(child).toString('utf-8');
+    }
+    else if (typeof child === 'string') {
+        return child;
+    }
+};
+export const getBinaryNodeChildUInt = (node, childTag, length) => {
+    const buff = getBinaryNodeChildBuffer(node, childTag);
+    if (buff) {
+        return bufferToUInt(buff, length);
+    }
+};
+export const assertNodeErrorFree = (node) => {
+    const errNode = getBinaryNodeChild(node, 'error');
+    if (errNode) {
+        throw new Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code });
+    }
+};
+export const reduceBinaryNodeToDictionary = (node, tag) => {
+    const nodes = getBinaryNodeChildren(node, tag);
+    const dict = nodes.reduce((dict, { attrs }) => {
+        if (typeof attrs.name === 'string') {
+            dict[attrs.name] = attrs.value || attrs.config_value;
+        }
+        else {
+            dict[attrs.config_code] = attrs.value || attrs.config_value;
+        }
+        return dict;
+    }, {});
+    return dict;
+};
+export const getBinaryNodeMessages = ({ content }) => {
+    const msgs = [];
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (item.tag === 'message') {
+                msgs.push(proto.WebMessageInfo.decode(item.content).toJSON());
+            }
+        }
+    }
+    return msgs;
+};
+function bufferToUInt(e, t) {
+    let a = 0;
+    for (let i = 0; i < t; i++) {
+        a = 256 * a + e[i];
+    }
+    return a;
+}
+const tabs = (n) => '\t'.repeat(n);
+export function binaryNodeToString(node, i = 0) {
+    if (!node) {
+        return node;
+    }
+    if (typeof node === 'string') {
+        return tabs(i) + node;
+    }
+    if (node instanceof Uint8Array) {
+        return tabs(i) + Buffer.from(node).toString('hex');
+    }
+    if (Array.isArray(node)) {
+        return node.map(x => tabs(i + 1) + binaryNodeToString(x, i + 1)).join('\n');
+    }
+    const children = binaryNodeToString(node.content, i + 1);
+    const tag = `<${node.tag} ${Object.entries(node.attrs || {})
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}='${v}'`)
+        .join(' ')}`;
+    const content = children ? `>\n${children}\n${tabs(i)}</${node.tag}>` : '/>';
+    return tag + content;
+}
+
+const FLOWS_MAP = {
+    mpm: true,
+    cta_catalog: true,
+    send_location: true,
+    call_permission_request: true,
+    wa_payment_transaction_details: true,
+    automated_greeting_message_view_catalog: true
+};
+const DECISION_SOURCE_CONTENT = [
+    {
+        tag: 'decision_source',
+        attrs: { value: 'df' }
+    }
+];
+const LIST_TYPE_CONTENT = {
+    tag: 'list',
+    attrs: { v: '2', type: 'product_list' }
+};
+const NATIVE_FLOW_ATTRIBUTE = { type: 'native_flow', v: '1' };
+const MIXED_NATIVE_FLOW = {
+    tag: 'interactive',
+    attrs: NATIVE_FLOW_ATTRIBUTE,
+    content: [
+        {
+            tag: 'native_flow',
+            attrs: { v: '9', name: 'mixed' }
+        }
+    ]
+};
+export const getBizBinaryNode = (message) => {
+    const flowMsg = message.interactiveMessage?.nativeFlowMessage;
+    const firstButtonName = flowMsg?.buttons?.[0]?.name;
+    const qualityContent = {
+        tag: 'quality_control',
+        attrs: {
+            decision_id: randomBytes(20).toString('hex'),
+            source_type: 'third_party'
+        },
+        content: DECISION_SOURCE_CONTENT
+    };
+    const bizAttributes = {
+        actual_actors: '2',
+        host_storage: '2',
+        privacy_mode_ts: `${Date.now() / 1_000 | 0}`
+    };
+    if (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info') {
+        bizAttributes.native_flow_name = firstButtonName === 'review_and_pay' ?
+            'order_details' :
+            firstButtonName;
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [qualityContent]
+        };
+    }
+    if (firstButtonName && FLOWS_MAP[firstButtonName]) {
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                {
+                    tag: 'interactive',
+                    attrs: NATIVE_FLOW_ATTRIBUTE,
+                    content: [
+                        {
+                            tag: 'native_flow',
+                            attrs: { v: '2', name: firstButtonName }
+                        }
+                    ]
+                },
+                qualityContent
+            ]
+        };
+    }
+    const carouselFlow = message.interactiveMessage?.carouselMessage?.cards?.some(card => card?.nativeFlowMessage);
+    if (flowMsg || carouselFlow || message.buttonsMessage || message.templateMessage) {
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                MIXED_NATIVE_FLOW,
+                qualityContent
+            ]
+        };
+    }
+    if (message.listMessage) {
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                LIST_TYPE_CONTENT,
+                qualityContent
+            ]
+        };
+    }
+    return {
+        tag: 'biz',
+        attrs: bizAttributes,
+        content: [qualityContent]
+    };
+};

package/src/WABinary/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./encode.js";
+export * from "./decode.js";
+export * from "./generic-utils.js";
+export * from "./jid-utils.js";
+export * from "./types.js";

package/src/WABinary/index.js

@@ -0,0 +1,5 @@
+export * from './encode.js';
+export * from './decode.js';
+export * from './generic-utils.js';
+export * from './jid-utils.js';
+export * from './types.js';

package/src/WABinary/jid-utils.d.ts

@@ -0,0 +1,30 @@
+export const S_WHATSAPP_NET: "@s.whatsapp.net";
+export const OFFICIAL_BIZ_JID: "16505361212@c.us";
+export const SERVER_JID: "server@c.us";
+export const PSA_WID: "0@c.us";
+export const STORIES_JID: "status@broadcast";
+export const LOCATION_BROADCAST_JID: "location@broadcast";
+export const META_AI_JID: "13135550002@c.us";
+export const WAJIDDomains: any;
+export function getServerFromDomainType(initialServer: any, domainType: any): any;
+export function jidEncode(user: any, server: any, device: any, agent: any): string;
+export function jidDecode(jid: any): {
+    server: any;
+    user: any;
+    domainType: any;
+    device: number | undefined;
+} | undefined;
+export function areJidsSameUser(jid1: any, jid2: any): boolean;
+export function isJidMetaAI(jid: any): any;
+export function isPnUser(jid: any): any;
+export function isLidUser(jid: any): any;
+export function isJidBroadcast(jid: any): any;
+export function isJidGroup(jid: any): any;
+export function isJidStatusBroadcast(jid: any): boolean;
+export function isJidLocationBroadcast(jid: any): boolean;
+export function isJidNewsletter(jid: any): any;
+export function isHostedPnUser(jid: any): any;
+export function isHostedLidUser(jid: any): any;
+export function isJidBot(jid: any): any;
+export function jidNormalizedUser(jid: any): string;
+export function transferDevice(fromJid: any, toJid: any): string;

package/src/WABinary/jid-utils.js

@@ -0,0 +1,97 @@
+export const S_WHATSAPP_NET = '@s.whatsapp.net';
+export const OFFICIAL_BIZ_JID = '16505361212@c.us';
+export const SERVER_JID = 'server@c.us';
+export const PSA_WID = '0@c.us';
+export const STORIES_JID = 'status@broadcast';
+export const LOCATION_BROADCAST_JID = 'location@broadcast';
+export const META_AI_JID = '13135550002@c.us';
+export var WAJIDDomains;
+(function (WAJIDDomains) {
+    WAJIDDomains[WAJIDDomains["WHATSAPP"] = 0] = "WHATSAPP";
+    WAJIDDomains[WAJIDDomains["LID"] = 1] = "LID";
+    WAJIDDomains[WAJIDDomains["HOSTED"] = 128] = "HOSTED";
+    WAJIDDomains[WAJIDDomains["HOSTED_LID"] = 129] = "HOSTED_LID";
+})(WAJIDDomains || (WAJIDDomains = {}));
+export const getServerFromDomainType = (initialServer, domainType) => {
+    switch (domainType) {
+        case WAJIDDomains.LID:
+            return 'lid';
+        case WAJIDDomains.HOSTED:
+            return 'hosted';
+        case WAJIDDomains.HOSTED_LID:
+            return 'hosted.lid';
+        case WAJIDDomains.WHATSAPP:
+        default:
+            return initialServer;
+    }
+};
+export const jidEncode = (user, server, device, agent) => {
+    return `${user || ''}${!!agent ? `_${agent}` : ''}${!!device ? `:${device}` : ''}@${server || 'lid'}`;
+};
+export const jidDecode = (jid) => {
+
+    const sepIdx = typeof jid === 'string' ? jid.indexOf('@') : -1;
+    if (sepIdx < 0) {
+        return undefined;
+    }
+    const server = jid.slice(sepIdx + 1);
+    const userCombined = jid.slice(0, sepIdx);
+    const [userAgent, device] = userCombined.split(':');
+    const [user, agent] = userAgent.split('_');
+    let domainType = WAJIDDomains.WHATSAPP;
+    if (server === 'lid') {
+        domainType = WAJIDDomains.LID;
+    }
+    else if (server === 'hosted') {
+        domainType = WAJIDDomains.HOSTED;
+    }
+    else if (server === 'hosted.lid') {
+        domainType = WAJIDDomains.HOSTED_LID;
+    }
+    else if (agent) {
+        domainType = parseInt(agent);
+    }
+    return {
+        server: server,
+        user: user,
+        domainType,
+        device: device ? +device : undefined
+    };
+};
+
+export const areJidsSameUser = (jid1, jid2) => jidDecode(jid1)?.user === jidDecode(jid2)?.user;
+
+export const isJidMetaAI = (jid) => jid?.endsWith('@bot');
+
+export const isPnUser = (jid) => jid?.endsWith('@s.whatsapp.net');
+
+export const isLidUser = (jid) => jid?.endsWith('@lid');
+
+export const isJidBroadcast = (jid) => jid?.endsWith('@broadcast');
+
+export const isJidGroup = (jid) => jid?.endsWith('@g.us');
+
+export const isJidStatusBroadcast = (jid) => jid === STORIES_JID;
+export const isJidLocationBroadcast = (jid) => jid === LOCATION_BROADCAST_JID;
+
+export const isJidNewsletter = (jid) => jid?.endsWith('@newsletter');
+
+export const isHostedPnUser = (jid) => jid?.endsWith('@hosted');
+
+export const isHostedLidUser = (jid) => jid?.endsWith('@hosted.lid');
+const botRegexp = /^1313555\d{4}$|^131655500\d{2}$/;
+export const isJidBot = (jid) => jid && botRegexp.test(jid.split('@')[0]) && jid.endsWith('@c.us');
+export const jidNormalizedUser = (jid) => {
+    const result = jidDecode(jid);
+    if (!result) {
+        return '';
+    }
+    const { user, server } = result;
+    return jidEncode(user, server === 'c.us' ? 's.whatsapp.net' : server);
+};
+export const transferDevice = (fromJid, toJid) => {
+    const fromDecoded = jidDecode(fromJid);
+    const deviceId = fromDecoded?.device || 0;
+    const { server, user } = jidDecode(toJid);
+    return jidEncode(user, server, deviceId);
+};

package/src/WABinary/types.d.ts

@@ -0,0 +1 @@
+export {};

package/src/WAM/BinaryInfo.d.ts

@@ -0,0 +1,7 @@
+export class BinaryInfo {
+    constructor(options?: {});
+    protocolVersion: number;
+    sequence: number;
+    events: any[];
+    buffer: any[];
+}

package/src/WAM/BinaryInfo.js

@@ -0,0 +1,9 @@
+export class BinaryInfo {
+    constructor(options = {}) {
+        this.protocolVersion = 5;
+        this.sequence = 0;
+        this.events = [];
+        this.buffer = [];
+        Object.assign(this, options);
+    }
+}