@skyzopedia/baileys-mod 3.0.9 → 4.0.1

package/lib/WABinary/generic-utils.js

@@ -1,113 +1,189 @@
-//=======================================================//
-import { proto } from "../../WAProto/index.js";
-import { Boom } from "@hapi/boom";
-import {} from "./types.js";
-//=======================================================//
+import { Boom } from '@hapi/boom';
+import { proto } from '../../WAProto/index.js';
+import {} from './types.js';
+import { unixTimestampSeconds } from '../Utils/index.js';
+
 export const getBinaryNodeChildren = (node, childTag) => {
-  if (Array.isArray(node?.content)) {
-    return node.content.filter(item => item.tag === childTag);
-  }
-  return [];
+    if (Array.isArray(node?.content)) {
+        return node.content.filter(item => item.tag === childTag);
+    }
+    return [];
 };
-//=======================================================//
 export const getAllBinaryNodeChildren = ({ content }) => {
-  if (Array.isArray(content)) {
-    return content;
-  }
-  return [];
+    if (Array.isArray(content)) {
+        return content;
+    }
+    return [];
 };
-//=======================================================//
 export const getBinaryNodeChild = (node, childTag) => {
-  if (Array.isArray(node?.content)) {
-    return node?.content.find(item => item.tag === childTag);
-  }
+    if (Array.isArray(node?.content)) {
+        return node?.content.find(item => item.tag === childTag);
+    }
 };
-//=======================================================//
 export const getBinaryNodeChildBuffer = (node, childTag) => {
-  const child = getBinaryNodeChild(node, childTag)?.content;
-  if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
-    return child;
-  }
+    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;
-  }
+    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);
-  }
+    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 });
-  }
+    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;
-    }
+    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;
-  }, {});
-  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());
-      }
+    const msgs = [];
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (item.tag === 'message') {
+                msgs.push(proto.WebMessageInfo.decode(item.content));
+            }
+        }
     }
-  }
-  return msgs;
+    return msgs;
 };
-//=======================================================//
 function bufferToUInt(e, t) {
-  let a = 0;
-  for (let i = 0; i < t; i++) {
-    a = 256 * a + e[i];
-  }
-  return a;
+    let a = 0;
+    for (let i = 0; i < t; i++) {
+        a = 256 * a + e[i];
+    }
+    return a;
 }
-//=======================================================//
-const tabs = (n) => "\t".repeat(n);
+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;
+    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;
+}
+export const getBinaryNodeFilter = (node) => {
+   if (!Array.isArray(node)) return false
+   
+   return node.some(item => 
+      ['native_flow'].includes(item?.content?.[0]?.content?.[0]?.tag) ||
+      ['interactive', 'buttons', 'list'].includes(item?.content?.[0]?.tag) ||
+      ['hsm', 'biz'].includes(item?.tag) ||
+      ['bot'].includes(item?.tag) && item?.attrs?.biz_bot === '1'
+   )
 }
-//=======================================================//
+export const getAdditionalNode = (name) => {
+   if (name) name = name.toLowerCase()
+   const ts = unixTimestampSeconds(new Date()) - 77980457
+   
+   const order_response_name = {
+      review_and_pay: 'order_details',
+      review_order: 'order_status',
+      payment_info: 'payment_info',
+      payment_status: 'payment_status',
+      payment_method: 'payment_method'
+   }
+   
+   const flow_name = {
+      cta_catalog: 'cta_catalog',
+      mpm: 'mpm',
+      call_request: 'call_permission_request',
+      view_catalog: 'automated_greeting_message_view_catalog',
+      wa_pay_detail: 'wa_payment_transaction_details',
+      send_location: 'send_location',
+   }
+   
+   if(order_response_name[name]) {
+       return [{
+           tag: 'biz',
+           attrs: { 
+               native_flow_name: order_response_name[name] 
+           },
+           content: []
+       }]
+   } else if (flow_name[name] || name === 'interactive' || name === 'buttons') {
+       return [{
+           tag: 'biz',
+           attrs: { 
+               actual_actors: '2',
+               host_storage: '2',
+               privacy_mode_ts: `${ts}`
+           },
+           content: [{
+               tag: 'engagement',
+               attrs: {
+                   customer_service_state: 'open',
+                   conversation_state: 'open'
+               }
+           }, {
+               tag: 'interactive',
+               attrs: {
+                   type: 'native_flow',
+                   v: '1'
+               },
+               content: [{
+                   tag: 'native_flow',
+                   attrs: { 
+                       v: '9',
+                       name: flow_name[name] ?? 'mixed',
+                   },
+                       content: []
+                   }]
+               }]
+           }]
+   } else {
+         return [{
+         tag: 'biz',
+         attrs: {
+            actual_actors: '2',
+            host_storage: '2',
+            privacy_mode_ts: `${ts}`
+         },
+         content: [{
+            tag: 'engagement',
+            attrs: {
+               customer_service_state: 'open',
+               conversation_state: 'open'
+            }
+         }]
+      }]
+   }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyzopedia/baileys-mod",
-  "version": "3.0.9",
+  "version": "4.0.1",
   "description": "Websocket Whatsapp API for Node.js",
   "keywords": [
     "whatsapp",

package/lib/Socket/newsletter.js.bak

@@ -1,247 +0,0 @@
-//=======================================================//
-import { executeWMexQuery as genericExecuteWMexQuery } from "./mex.js";
-import { generateProfilePicture } from "../Utils/messages-media.js";
-import { getBinaryNodeChild } from "../WABinary/index.js";
-import { QueryIds, XWAPaths } from "../Types/index.js";
-import { makeGroupsSocket } from "./groups.js";
-//=======================================================//
-    
-const extractNewsletterMetadata = (node, isCreate) => {
-    const result = getBinaryNodeChild(node, 'result')?.content?.toString()
-    const metadataPath = JSON.parse(result).data[isCreate ? XWAPaths.xwa2_newsletter_create : "xwa2_newsletter"]
-    
-    const metadata = {
-        id: metadataPath?.id,
-        state: metadataPath?.state?.type,
-        creation_time: +metadataPath?.thread_metadata?.creation_time,
-        name: metadataPath?.thread_metadata?.name?.text,
-        nameTime: +metadataPath?.thread_metadata?.name?.update_time,
-        description: metadataPath?.thread_metadata?.description?.text,
-        descriptionTime: +metadataPath?.thread_metadata?.description?.update_time,
-        invite: metadataPath?.thread_metadata?.invite,
-        handle: metadataPath?.thread_metadata?.handle,
-        reaction_codes: metadataPath?.thread_metadata?.settings?.reaction_codes?.value,
-        subscribers: +metadataPath?.thread_metadata?.subscribers_count,
-        verification: metadataPath?.thread_metadata?.verification,
-        viewer_metadata: metadataPath?.viewer_metadata
-    }
-    return metadata
-}
-    
-const parseNewsletterCreateResponse = (response) => {
-  const { id, thread_metadata: thread, viewer_metadata: viewer } = response;
-  return {
-    id: id,
-    owner: undefined,
-    name: thread.name.text,
-    creation_time: parseInt(thread.creation_time, 10),
-    description: thread.description.text,
-    invite: thread.invite,
-    subscribers: parseInt(thread.subscribers_count, 10),
-    verification: thread.verification,
-    picture: {
-      id: thread.picture.id,
-      directPath: thread.picture.direct_path
-    },
-    mute_state: viewer.mute
-  };
-};
-const parseNewsletterMetadata = (result) => {
-  if (typeof result !== "object" || result === null) {
-    return null;
-  }
-  if ("id" in result && typeof result.id === "string") {
-    return result;
-  }
-  if ("result" in result && typeof result.result === "object" && result.result !== null && "id" in result.result) {
-    return result.result;
-  }
-  return null;
-};
-
-export const makeNewsletterSocket = (config) => {
-  const sock = makeGroupsSocket(config);
-  const { query, generateMessageTag } = sock;
-  const encoder = new TextEncoder()
-  const newsletterWMexQuery = async (jid, queryId, content) => (query({
-        tag: 'iq',
-        attrs: {
-            id: generateMessageTag(),
-            type: 'get',
-            xmlns: 'w:mex',
-            to: "@s.whatsapp.net",
-        },
-        content: [
-            {
-                tag: 'query',
-                attrs: { 'query_id': queryId },
-                content: encoder.encode(JSON.stringify({
-                    variables: {
-                        'newsletter_id': jid,
-                        ...content
-                    }
-                }))
-            }
-        ]
-    }))
-  const executeWMexQuery = (variables, queryId, dataPath) => {
-    return genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
-  };
-  const newsletterMetadata = async (type, key, role) => {
-        const result = await newsletterWMexQuery(undefined, QueryIds.METADATA, {
-            input: {
-                key,
-                type: type.toUpperCase(),
-                view_role: role || 'GUEST'
-            },
-            fetch_viewer_metadata: true,
-            fetch_full_image: true,
-            fetch_creation_time: true
-        })
-            
-        return extractNewsletterMetadata(result)
-    }
-  const newsletterUpdate = async (jid, updates) => {
-    const variables = {
-      newsletter_id: jid,
-      updates: {
-        ...updates,
-        settings: null
-      }
-    };
-    return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, "xwa2_newsletter_update");
-  };
-  return {
-    ...sock,
-    newsletterCreate: async (name, description) => {
-      const variables = {
-        input: {
-          name,
-          description: description ?? null
-        }
-      };
-      const rawResponse = await executeWMexQuery(variables, QueryIds.CREATE, XWAPaths.xwa2_newsletter_create);
-      return parseNewsletterCreateResponse(rawResponse);
-    },
-    newsletterUpdate,
-    newsletterSubscribers: async (jid) => {
-      return executeWMexQuery({ newsletter_id: jid }, QueryIds.SUBSCRIBERS, XWAPaths.xwa2_newsletter_subscribers);
-    },
-    newsletterMetadata, 
-    newsletterFetchAllParticipating: async () => {
-        	const data = {}
-        
-        	const result = await newsletterWMexQuery(undefined, QueryIds.SUBSCRIBERS) 
-        	const child = JSON.parse(getBinaryNodeChild(result, 'result')?.content?.toString())
-        	const newsletters = child.data["xwa2_newsletter_subscribed"]
-        
-        	for (const i of newsletters) {
-        		if (i.id == null) continue
-        	
-        		const metadata = await newsletterMetadata('JID', i.id) 
-        		if (metadata.id !== null) data[metadata.id] = metadata
-        	}
-        	
-        	return data
-        },
-    newsletterUnfollow: async (jid) => {
-            await newsletterWMexQuery(jid, QueryIds.UNFOLLOW)
-        },
-        newsletterFollow: async (jid) => {
-            await newsletterWMexQuery(jid, QueryIds.FOLLOW)
-        },
-    newsletterMute: (jid) => {
-      return executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2);
-    },
-    newsletterUnmute: (jid) => {
-      return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2);
-    },
-    newsletterUpdateName: async (jid, name) => {
-      return await newsletterUpdate(jid, { name });
-    },
-    newsletterUpdateDescription: async (jid, description) => {
-      return await newsletterUpdate(jid, { description });
-    },
-    newsletterUpdatePicture: async (jid, content) => {
-      const { img } = await generateProfilePicture(content);
-      return await newsletterUpdate(jid, { picture: img.toString("base64") });
-    },
-    newsletterRemovePicture: async (jid) => {
-      return await newsletterUpdate(jid, { picture: "" });
-    },
-    newsletterReactMessage: async (jid, serverId, reaction) => {
-      await query({
-        tag: "message",
-        attrs: {
-          to: jid,
-          ...(reaction ? {} : { edit: "7" }),
-          type: "reaction",
-          server_id: serverId,
-          id: generateMessageTag()
-        },
-        content: [
-          {
-            tag: "reaction",
-            attrs: reaction ? { code: reaction } : {}
-          }
-        ]
-      });
-    },
-    newsletterFetchMessages: async (jid, count, since, after) => {
-      const messageUpdateAttrs = {
-        count: count.toString()
-      };
-      if (typeof since === "number") {
-        messageUpdateAttrs.since = since.toString();
-      }
-      if (after) {
-        messageUpdateAttrs.after = after.toString();
-      }
-      const result = await query({
-        tag: "iq",
-        attrs: {
-          id: generateMessageTag(),
-          type: "get",
-          xmlns: "newsletter",
-          to: jid
-        },
-        content: [
-          {
-            tag: "message_updates",
-            attrs: messageUpdateAttrs
-          }
-        ]
-      });
-      return result;
-    },
-    subscribeNewsletterUpdates: async (jid) => {
-      const result = await query({
-        tag: "iq",
-        attrs: {
-          id: generateMessageTag(),
-          type: "set",
-          xmlns: "newsletter",
-          to: jid
-        },
-        content: [{ tag: "live_updates", attrs: {}, content: [] }]
-      });
-      const liveUpdatesNode = getBinaryNodeChild(result, "live_updates");
-      const duration = liveUpdatesNode?.attrs?.duration;
-      return duration ? { duration: duration } : null;
-    },
-    newsletterAdminCount: async (jid) => {
-      const response = await executeWMexQuery({ newsletter_id: jid }, QueryIds.ADMIN_COUNT, XWAPaths.xwa2_newsletter_admin_count);
-      return response.admin_count;
-    },
-    newsletterChangeOwner: async (jid, newOwnerJid) => {
-      await executeWMexQuery({ newsletter_id: jid, user_id: newOwnerJid }, QueryIds.CHANGE_OWNER, XWAPaths.xwa2_newsletter_change_owner);
-    },
-    newsletterDemote: async (jid, userJid) => {
-      await executeWMexQuery({ newsletter_id: jid, user_id: userJid }, QueryIds.DEMOTE, XWAPaths.xwa2_newsletter_demote);
-    },
-    newsletterDelete: async (jid) => {
-      await executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.xwa2_newsletter_delete_v2);
-    }
-  };
-};
-//=======================================================//