dread-fork 2.0.0-dread.0

package/lib/Socket/dugong.js

@@ -0,0 +1,509 @@
+const WAProto = require("../../WAProto").proto,
+  crypto = require("crypto"),
+  Utils_1 = require("../Utils");
+class xeonDugong {
+  constructor(utils, waUploadToServer, relayMessageFn) {
+    this.utils = utils;
+    this.relayMessage = relayMessageFn;
+    this.waUploadToServer = waUploadToServer;
+    this.bail = {
+      generateWAMessageContent: this.utils.generateWAMessageContent || Utils_1.generateWAMessageContent,
+      generateMessageID: Utils_1.generateMessageID,
+      getContentType: msg => {
+        return Object.keys(msg.message || {})[0];
+      }
+    };
+  }
+  detectType(content) {
+    if (content.requestPaymentMessage) {
+      return "PAYMENT";
+    }
+    if (content.productMessage) {
+      return "PRODUCT";
+    }
+    if (content.interactiveMessage) {
+      return "INTERACTIVE";
+    }
+    if (content.albumMessage) {
+      return "ALBUM";
+    }
+    if (content.eventMessage) {
+      return "EVENT";
+    }
+    if (content.pollResultMessage) {
+      return "POLL_RESULT";
+    }
+    if (content.groupStatusMessage) {
+      return "GROUP_STORY";
+    }
+    return null;
+  }
+  async handlePayment(content, quoted) {
+    const data = content.requestPaymentMessage;
+    let notes = {};
+    if (data.sticker?.stickerMessage) {
+      notes = {
+        stickerMessage: {
+          ...data.sticker.stickerMessage,
+          contextInfo: {
+            stanzaId: quoted?.key?.id,
+            participant: quoted?.key?.participant || content.sender,
+            quotedMessage: quoted?.message
+          }
+        }
+      };
+    } else {
+      if (data.note) {
+        notes = {
+          extendedTextMessage: {
+            text: data.note,
+            contextInfo: {
+              stanzaId: quoted?.key?.id,
+              participant: quoted?.key?.participant || content.sender,
+              quotedMessage: quoted?.message
+            }
+          }
+        };
+      }
+    }
+    return {
+      requestPaymentMessage: WAProto.Message.RequestPaymentMessage.fromObject({
+        expiryTimestamp: data.expiry || 0,
+        amount1000: data.amount || 0,
+        currencyCodeIso4217: data.currency || "IDR",
+        requestFrom: data.from || "0@s.whatsapp.net",
+        noteMessage: notes,
+        background: data.background ?? {
+          id: "DEFAULT",
+          placeholderArgb: 0xfff0f0f0
+        }
+      })
+    };
+  }
+  async handleProduct(content, jid, quoted) {
+    const {
+      title: title,
+      description: description,
+      thumbnail: thumbnail,
+      productId: productId,
+      retailerId: retailerId,
+      url: url,
+      body = "",
+      footer = "",
+      buttons = [],
+      priceAmount1000 = null,
+      currencyCode = "IDR"
+    } = content.productMessage;
+    let productImage;
+    if (Buffer.isBuffer(thumbnail)) {
+      const {
+        imageMessage: imageMessage
+      } = await this.utils.generateWAMessageContent({
+        image: thumbnail
+      }, {
+        upload: this.waUploadToServer
+      });
+      productImage = imageMessage;
+    } else {
+      if (typeof thumbnail === "object" && thumbnail.url) {
+        const {
+          imageMessage: imageMessage
+        } = await this.utils.generateWAMessageContent({
+          image: {
+            url: thumbnail.url
+          }
+        }, {
+          upload: this.waUploadToServer
+        });
+        productImage = imageMessage;
+      }
+    }
+    return {
+      viewOnceMessage: {
+        message: {
+          interactiveMessage: {
+            body: {
+              text: body
+            },
+            footer: {
+              text: footer
+            },
+            header: {
+              title: title,
+              hasMediaAttachment: true,
+              productMessage: {
+                product: {
+                  productImage: productImage,
+                  productId: productId,
+                  title: title,
+                  description: description,
+                  currencyCode: currencyCode,
+                  priceAmount1000: priceAmount1000,
+                  retailerId: retailerId,
+                  url: url,
+                  productImageCount: 1
+                },
+                businessOwnerJid: "0@s.whatsapp.net"
+              }
+            },
+            nativeFlowMessage: {
+              buttons: buttons
+            }
+          }
+        }
+      }
+    };
+  }
+  async handleInteractive(content, jid, quoted) {
+    const {
+      title: title,
+      footer: footer,
+      thumbnail: thumbnail,
+      image: image,
+      video: video,
+      document: document,
+      mimetype: mimetype,
+      fileName: fileName,
+      jpegThumbnail: jpegThumbnail,
+      contextInfo: contextInfo,
+      externalAdReply: externalAdReply,
+      buttons = [],
+      nativeFlowMessage: nativeFlowMessage,
+      header: header
+    } = content.interactiveMessage;
+    let media = null,
+      mediaType = null;
+    if (thumbnail) {
+      media = await this.utils.prepareWAMessageMedia({
+        image: {
+          url: thumbnail
+        }
+      }, {
+        upload: this.waUploadToServer
+      });
+      mediaType = "image";
+    } else {
+      if (image) {
+        if (typeof image === "object" && image.url) {
+          media = await this.utils.prepareWAMessageMedia({
+            image: {
+              url: image.url
+            }
+          }, {
+            upload: this.waUploadToServer
+          });
+        } else {
+          media = await this.utils.prepareWAMessageMedia({
+            image: image
+          }, {
+            upload: this.waUploadToServer
+          });
+        }
+        mediaType = "image";
+      } else {
+        if (video) {
+          if (typeof video === "object" && video.url) {
+            media = await this.utils.prepareWAMessageMedia({
+              video: {
+                url: video.url
+              }
+            }, {
+              upload: this.waUploadToServer
+            });
+          } else {
+            media = await this.utils.prepareWAMessageMedia({
+              video: video
+            }, {
+              upload: this.waUploadToServer
+            });
+          }
+          mediaType = "video";
+        } else {
+          if (document) {
+            let documentPayload = {
+              document: document
+            };
+            if (jpegThumbnail) {
+              if (typeof jpegThumbnail === "object" && jpegThumbnail.url) {
+                documentPayload.jpegThumbnail = {
+                  url: jpegThumbnail.url
+                };
+              } else {
+                documentPayload.jpegThumbnail = jpegThumbnail;
+              }
+            }
+            media = await this.utils.prepareWAMessageMedia(documentPayload, {
+              upload: this.waUploadToServer
+            });
+            if (fileName) {
+              media.documentMessage.fileName = fileName;
+            }
+            if (mimetype) {
+              media.documentMessage.mimetype = mimetype;
+            }
+            mediaType = "document";
+          }
+        }
+      }
+    }
+    let interactiveMessage = {
+      body: {
+        text: title || ""
+      },
+      footer: {
+        text: footer || ""
+      }
+    };
+    if (buttons && buttons.length > 0) {
+      interactiveMessage.nativeFlowMessage = {
+        buttons: buttons
+      };
+      if (nativeFlowMessage) {
+        interactiveMessage.nativeFlowMessage = {
+          ...interactiveMessage.nativeFlowMessage,
+          ...nativeFlowMessage
+        };
+      }
+    } else {
+      if (nativeFlowMessage) {
+        interactiveMessage.nativeFlowMessage = nativeFlowMessage;
+      }
+    }
+    if (media) {
+      interactiveMessage.header = {
+        title: header || "",
+        hasMediaAttachment: true,
+        ...media
+      };
+    } else {
+      interactiveMessage.header = {
+        title: header || "",
+        hasMediaAttachment: false
+      };
+    }
+    let finalContextInfo = {};
+    if (contextInfo) {
+      finalContextInfo = {
+        mentionedJid: contextInfo.mentionedJid || [],
+        forwardingScore: contextInfo.forwardingScore || 0,
+        isForwarded: contextInfo.isForwarded || false,
+        ...contextInfo
+      };
+    }
+    if (externalAdReply) {
+      finalContextInfo.externalAdReply = {
+        title: externalAdReply.title || "",
+        body: externalAdReply.body || "",
+        mediaType: externalAdReply.mediaType || 1,
+        thumbnailUrl: externalAdReply.thumbnailUrl || "",
+        mediaUrl: externalAdReply.mediaUrl || "",
+        sourceUrl: externalAdReply.sourceUrl || "",
+        showAdAttribution: externalAdReply.showAdAttribution || false,
+        renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false,
+        ...externalAdReply
+      };
+    }
+    if (Object.keys(finalContextInfo).length > 0) {
+      interactiveMessage.contextInfo = finalContextInfo;
+    }
+    return {
+      interactiveMessage: interactiveMessage
+    };
+  }
+  async handleAlbum(content, jid, quoted) {
+    const array = content.albumMessage,
+      album = await this.utils.generateWAMessageFromContent(jid, {
+        messageContextInfo: {
+          messageSecret: crypto.randomBytes(32)
+        },
+        albumMessage: {
+          expectedImageCount: array.filter(a => {
+            return a.hasOwnProperty("image");
+          }).length,
+          expectedVideoCount: array.filter(a => {
+            return a.hasOwnProperty("video");
+          }).length
+        }
+      }, {
+        userJid: this.utils.generateMessageID().split("@")[0] + "@s.whatsapp.net",
+        quoted: quoted,
+        upload: this.waUploadToServer
+      });
+    await this.relayMessage(jid, album.message, {
+      messageId: album.key.id
+    });
+    for (let content of array) {
+      const img = await this.utils.generateWAMessage(jid, content, {
+        upload: this.waUploadToServer
+      });
+      img.message.messageContextInfo = {
+        messageSecret: crypto.randomBytes(32),
+        messageAssociation: {
+          associationType: 1,
+          parentMessageKey: album.key
+        },
+        participant: "0@s.whatsapp.net",
+        remoteJid: "status@broadcast",
+        forwardingScore: 0x1869f,
+        isForwarded: true,
+        mentionedJid: [jid],
+        starred: true,
+        labels: ["Y", "Important"],
+        isHighlighted: true,
+        businessMessageForwardInfo: {
+          businessOwnerJid: jid
+        },
+        dataSharingContext: {
+          showMmDisclosure: true
+        }
+      };
+      img.message.forwardedNewsletterMessageInfo = {
+        newsletterJid: "0@newsletter",
+        serverMessageId: 1,
+        newsletterName: "WhatsApp",
+        contentType: 1,
+        timestamp: new Date().toISOString(),
+        senderName: "Telegram: @dgxeon13",
+        content: "Text Message",
+        priority: "high",
+        status: "sent"
+      };
+      img.message.disappearingMode = {
+        initiator: 3,
+        trigger: 4,
+        initiatorDeviceJid: jid,
+        initiatedByExternalService: true,
+        initiatedByUserDevice: true,
+        initiatedBySystem: true,
+        initiatedByServer: true,
+        initiatedByAdmin: true,
+        initiatedByUser: true,
+        initiatedByApp: true,
+        initiatedByBot: true,
+        initiatedByMe: true
+      };
+      await this.relayMessage(jid, img.message, {
+        messageId: img.key.id,
+        quoted: {
+          key: {
+            remoteJid: album.key.remoteJid,
+            id: album.key.id,
+            fromMe: true,
+            participant: this.utils.generateMessageID().split("@")[0] + "@s.whatsapp.net"
+          },
+          message: album.message
+        }
+      });
+    }
+    return album;
+  }
+  async handleEvent(content, jid, quoted) {
+    const eventData = content.eventMessage,
+      msg = await this.utils.generateWAMessageFromContent(jid, {
+        viewOnceMessage: {
+          message: {
+            messageContextInfo: {
+              deviceListMetadata: {},
+              deviceListMetadataVersion: 2,
+              messageSecret: crypto.randomBytes(32),
+              supportPayload: JSON.stringify({
+                version: 2,
+                is_ai_message: true,
+                should_show_system_message: true,
+                ticket_id: crypto.randomBytes(16).toString("hex")
+              })
+            },
+            eventMessage: {
+              contextInfo: {
+                mentionedJid: [jid],
+                participant: jid,
+                remoteJid: "status@broadcast",
+                forwardedNewsletterMessageInfo: {
+                  newsletterName: "shenvn.",
+                  newsletterJid: "120363297591152843@newsletter",
+                  serverMessageId: 1
+                }
+              },
+              isCanceled: eventData.isCanceled || false,
+              name: eventData.name,
+              description: eventData.description,
+              location: eventData.location || {
+                degreesLatitude: 0,
+                degreesLongitude: 0,
+                name: "Location"
+              },
+              joinLink: eventData.joinLink || "",
+              startTime: typeof eventData.startTime === "string" ? parseInt(eventData.startTime) : eventData.startTime || Date.now(),
+              endTime: typeof eventData.endTime === "string" ? parseInt(eventData.endTime) : eventData.endTime || Date.now() + 0x36ee80,
+              extraGuestsAllowed: eventData.extraGuestsAllowed !== false
+            }
+          }
+        }
+      }, {
+        quoted: quoted
+      });
+    await this.relayMessage(jid, msg.message, {
+      messageId: msg.key.id
+    });
+    return msg;
+  }
+  async handlePollResult(content, jid, quoted) {
+    const pollData = content.pollResultMessage,
+      msg = await this.utils.generateWAMessageFromContent(jid, {
+        pollResultSnapshotMessage: {
+          name: pollData.name,
+          pollVotes: pollData.pollVotes.map(vote => {
+            return {
+              optionName: vote.optionName,
+              optionVoteCount: typeof vote.optionVoteCount === "number" ? vote.optionVoteCount.toString() : vote.optionVoteCount
+            };
+          })
+        }
+      }, {
+        userJid: this.utils.generateMessageID().split("@")[0] + "@s.whatsapp.net",
+        quoted: quoted
+      });
+    await this.relayMessage(jid, msg.message, {
+      messageId: msg.key.id
+    });
+    return msg;
+  }
+  async handleGroupStory(content, jid, quoted) {
+    const storyData = content.groupStatusMessage;
+    let waMsgContent;
+    if (storyData.message) {
+      waMsgContent = storyData;
+    } else {
+      if (typeof this.bail?.generateWAMessageContent === "function") {
+        waMsgContent = await this.bail.generateWAMessageContent(storyData, {
+          upload: this.waUploadToServer
+        });
+      } else {
+        if (typeof this.utils?.generateWAMessageContent === "function") {
+          waMsgContent = await this.utils.generateWAMessageContent(storyData, {
+            upload: this.waUploadToServer
+          });
+        } else {
+          if (typeof this.utils?.prepareMessageContent === "function") {
+            waMsgContent = await this.utils.prepareMessageContent(storyData, {
+              upload: this.waUploadToServer
+            });
+          } else {
+            waMsgContent = await Utils_1.generateWAMessageContent(storyData, {
+              upload: this.waUploadToServer
+            });
+          }
+        }
+      }
+    }
+    let __p_DyNt_msg_message = {
+      groupStatusMessageV2: {
+        message: waMsgContent.message || waMsgContent
+      }
+    };
+    return await this.relayMessage(jid, __p_DyNt_msg_message, {
+      messageId: this.bail.generateMessageID()
+    });
+  }
+}
+module.exports = xeonDugong;

package/lib/Socket/groups.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="node" />
+import { proto } from '../../WAProto';
+import { GroupMetadata, ParticipantAction, SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const makeGroupsSocket: (config: SocketConfig) => {
+    groupMetadata: (jid: string) => Promise<GroupMetadata>;
+    groupCreate: (subject: string, participants: string[]) => Promise<GroupMetadata>;
+    groupLeave: (id: string) => Promise<void>;
+    groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
+    groupRequestParticipantsList: (jid: string) => Promise<{
+        [key: string]: string;
+    }[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<{
+        status: string;
+        jid: string;
+    }[]>;
+    groupParticipantsUpdate: (jid: string, participants: string[], action: ParticipantAction) => Promise<{
+        status: string;
+        jid: string;
+        content: BinaryNode;
+    }[]>;
+    groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
+    groupInviteCode: (jid: string) => Promise<string | undefined>;
+    groupRevokeInvite: (jid: string) => Promise<string | undefined>;
+    groupAcceptInvite: (code: string) => Promise<string | undefined>;
+    /**
+     * accept a GroupInviteMessage
+     * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
+     * @param inviteMessage the message to accept
+     */
+    groupAcceptInviteV4: (key: string | proto.IMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<string>;
+    groupGetInviteInfo: (code: string) => Promise<GroupMetadata>;
+    groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: 'announcement' | 'not_announcement' | 'locked' | 'unlocked') => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    groupFetchAllParticipating: () => Promise<{
+        [_: string]: GroupMetadata;
+    }>;
+    processingMutex: {
+        mutex<T>(code: () => T | Promise<T>): Promise<T>;
+    };
+    fetchPrivacySettings: (force?: boolean) => Promise<{
+        [_: string]: string;
+    }>;
+    upsertMessage: (msg: proto.IWebMessageInfo, type: import("../Types").MessageUpsertType) => Promise<void>;
+    appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>;
+    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string | undefined) => Promise<void>;
+    presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
+    profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
+    onWhatsApp: (...jids: string[]) => Promise<{
+        jid: string;
+        exists: unknown;
+        lid: unknown;
+    }[] | undefined>;
+    fetchBlocklist: () => Promise<string[]>;
+    fetchStatus: (jid: string) => Promise<{
+        status: string | undefined;
+        setAt: Date;
+    } | undefined>;
+    updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    removeProfilePicture: (jid: string) => Promise<void>;
+    updateProfileStatus: (status: string) => Promise<void>;
+    updateProfileName: (name: string) => Promise<void>;
+    updateBlockStatus: (jid: string, action: "block" | "unblock") => Promise<void>;
+    updateLastSeenPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: import("../Types").WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: import("../Types").WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateDefaultDisappearingMode: (duration: number) => Promise<void>;
+    getBusinessProfile: (jid: string) => Promise<void | import("../Types").WABusinessProfile>;
+    resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
+    chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => Promise<void>;
+    addChatLabel: (jid: string, labelId: string) => Promise<void>;
+    removeChatLabel: (jid: string, labelId: string) => Promise<void>;
+    addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    star: (jid: string, messages: {
+        id: string;
+        fromMe?: boolean | undefined;
+    }[], star: boolean) => Promise<void>;
+    type: "md";
+    ws: any;
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
+        buffer(): void;
+        createBufferedFunction<A extends any[], T_1>(work: (...args: A) => Promise<T_1>): (...args: A) => Promise<T_1>;
+        flush(force?: boolean | undefined): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>;
+    waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string | undefined) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
+    uploadPreKeys: (count?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
+};
+export declare const extractGroupMetadata: (result: BinaryNode) => GroupMetadata;