@skyzopedia/baileys-mod 3.0.2

package/lib/Utils/generics.js

@@ -0,0 +1,355 @@
+//=======================================================//
+import { getAllBinaryNodeChildren, jidDecode } from "../WABinary/index.js";
+import { DisconnectReason } from "../Types/index.js";
+import { createHash, randomBytes } from "crypto";
+import { proto } from "../../WAProto/index.js";
+import { version } from "../Defaults/index.js"
+import { sha256 } from "./crypto.js";
+import { Boom } from "@hapi/boom";
+//=======================================================//
+export const BufferJSON = {
+  replacer: (k, value) => {
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === "Buffer") {
+      return { type: "Buffer", data: Buffer.from(value?.data || value).toString("base64") };
+    }
+    return value;
+  },
+  reviver: (_, value) => {
+    if (typeof value === "object" && value !== null && value.type === "Buffer" && typeof value.data === "string") {
+      return Buffer.from(value.data, "base64");
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const keys = Object.keys(value);
+      if (keys.length > 0 && keys.every(k => !isNaN(parseInt(k, 10)))) {
+        const values = Object.values(value);
+        if (values.every(v => typeof v === "number")) {
+          return Buffer.from(values);
+        }
+      }
+    }
+    return value;
+  }
+};
+//=======================================================//
+export const getKeyAuthor = (key, meId = "me") => (key?.fromMe ? meId : key?.participant || key?.remoteJid) || "";
+export const writeRandomPadMax16 = (msg) => {
+  const pad = randomBytes(1);
+  const padLength = (pad[0] & 0x0f) + 1;
+  return Buffer.concat([msg, Buffer.alloc(padLength, padLength)]);
+};
+//=======================================================//
+export const unpadRandomMax16 = (e) => {
+  const t = new Uint8Array(e);
+  if (0 === t.length) {
+    throw new Error("unpadPkcs7 given empty bytes");
+  }
+  var r = t[t.length - 1];
+  if (r > t.length) {
+    throw new Error(`unpad given ${t.length} bytes, but pad is ${r}`);
+  }
+  return new Uint8Array(t.buffer, t.byteOffset, t.length - r);
+};
+//=======================================================//
+export const generateParticipantHashV2 = (participants) => {
+  participants.sort();
+  const sha256Hash = sha256(Buffer.from(participants.join(""))).toString("base64");
+  return "2:" + sha256Hash.slice(0, 6);
+};
+//=======================================================//
+export const encodeWAMessage = (message) => writeRandomPadMax16(proto.Message.encode(message).finish());
+export const generateRegistrationId = () => {
+  return Uint16Array.from(randomBytes(2))[0] & 16383;
+};
+//=======================================================//
+export const encodeBigEndian = (e, t = 4) => {
+  let r = e;
+  const a = new Uint8Array(t);
+  for (let i = t - 1; i >= 0; i--) {
+    a[i] = 255 & r;
+    r >>>= 8;
+  }
+  return a;
+};
+export const toNumber = (t) => typeof t === "object" && t ? ("toNumber" in t ? t.toNumber() : t.low) : t || 0;
+//=======================================================//
+export const unixTimestampSeconds = (date = new Date()) => Math.floor(date.getTime() / 1000);
+export const debouncedTimeout = (intervalMs = 1000, task) => {
+  let timeout;
+  return {
+    start: (newIntervalMs, newTask) => {
+      task = newTask || task;
+      intervalMs = newIntervalMs || intervalMs;
+      timeout && clearTimeout(timeout);
+      timeout = setTimeout(() => task?.(), intervalMs);
+    },
+    cancel: () => {
+      timeout && clearTimeout(timeout);
+      timeout = undefined;
+    },
+    setTask: (newTask) => (task = newTask),
+    setInterval: (newInterval) => (intervalMs = newInterval)
+  };
+};
+//=======================================================//
+export const delay = (ms) => delayCancellable(ms).delay;
+export const delayCancellable = (ms) => {
+  const stack = new Error().stack;
+  let timeout;
+  let reject;
+  const delay = new Promise((resolve, _reject) => {
+    timeout = setTimeout(resolve, ms);
+    reject = _reject;
+  });
+  const cancel = () => {
+    clearTimeout(timeout);
+    reject(new Boom("Cancelled", {
+      statusCode: 500,
+      data: {
+        stack
+      }
+    }));
+  };
+  return { delay, cancel };
+};
+//=======================================================//
+export async function promiseTimeout(ms, promise) {
+  return new Promise(promise);
+}
+//=======================================================//
+export const generateMessageIDV2 = (userId) => {
+  const data = Buffer.alloc(8 + 20 + 16);
+  data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1000)));
+  if (userId) {
+    const id = jidDecode(userId);
+    if (id?.user) {
+      data.write(id.user, 8);
+      data.write("@c.us", 8 + id.user.length);
+    }
+  }
+  const random = randomBytes(16);
+  random.copy(data, 28);
+  const hash = createHash("sha256").update(data).digest();
+  return "3EB0" + hash.toString("hex").toUpperCase().substring(0, 18);
+};
+//=======================================================//
+export const generateMessageID = () => "3EB0" + randomBytes(18).toString("hex").toUpperCase();
+export function bindWaitForEvent(ev, event) {
+  return async (check, timeoutMs) => {
+    let listener;
+    let closeListener;
+    await promiseTimeout(timeoutMs, (resolve, reject) => {
+      closeListener = ({ connection, lastDisconnect }) => {
+        if (connection === "close") {
+          reject(lastDisconnect?.error || new Boom("Connection Closed", { statusCode: DisconnectReason.connectionClosed }));
+        }
+      };
+      ev.on("connection.update", closeListener);
+      listener = async (update) => {
+        if (await check(update)) {
+          resolve();
+        }
+      };
+      ev.on(event, listener);
+    }).finally(() => {
+      ev.off(event, listener);
+      ev.off("connection.update", closeListener);
+    });
+  };
+}
+export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, "connection.update");
+//=======================================================//
+export const fetchLatestBaileysVersion = async (options = {}) => {
+  const URL = "https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts";
+  try {
+    const response = await fetch(URL, {
+      dispatcher: options.dispatcher,
+      method: "GET",
+      headers: options.headers
+    });
+    if (!response.ok) {
+      throw new Boom(`Failed to fetch latest Baileys version: ${response.statusText}`, { statusCode: response.status });
+    }
+    const text = await response.text();
+    const lines = text.split("\n");
+    const versionLine = lines[6];
+    const versionMatch = versionLine.match(/const version = \[(\d+),\s*(\d+),\s*(\d+)\]/);
+    if (versionMatch) {
+      const version = [parseInt(versionMatch[1]), parseInt(versionMatch[2]), parseInt(versionMatch[3])];
+      return {
+        version,
+        isLatest: true
+      };
+    }
+    else {
+      throw new Error("Could not parse version from Defaults/index.ts");
+    }
+  }
+  catch (error) {
+    return {
+      version: version,
+      isLatest: false,
+      error
+    };
+  }
+};
+//=======================================================//
+export const fetchLatestWaWebVersion = async (options = {}) => {
+  try {
+    const defaultHeaders = {
+      "sec-fetch-site": "none",
+      "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+    };
+    const headers = { ...defaultHeaders, ...options.headers };
+    const response = await fetch("https://web.whatsapp.com/sw.js", {
+      ...options,
+      method: "GET",
+      headers
+    });
+    if (!response.ok) {
+      throw new Boom(`Failed to fetch sw.js: ${response.statusText}`, { statusCode: response.status });
+    }
+    const data = await response.text();
+    const regex = /\\?"client_revision\\?":\s*(\d+)/;
+    const match = data.match(regex);
+    if (!match?.[1]) {
+      return {
+        version: version,
+        isLatest: false,
+        error: {
+          message: "Could not find client revision in the fetched content"
+        }
+      };
+    }
+    const clientRevision = match[1];
+    return {
+      version: [2, 3000, +clientRevision],
+      isLatest: true
+    };
+  }
+  catch (error) {
+    return {
+      version: version,
+      isLatest: false,
+      error
+    };
+  }
+};
+//=======================================================//
+export const generateMdTagPrefix = () => {
+  const bytes = randomBytes(4);
+  return `${bytes.readUInt16BE()}.${bytes.readUInt16BE(2)}-`;
+};
+//=======================================================//
+const STATUS_MAP = {
+  "sender": proto.WebMessageInfo.Status.SERVER_ACK,
+  "played": proto.WebMessageInfo.Status.PLAYED,
+  "read": proto.WebMessageInfo.Status.READ,
+  "read-self": proto.WebMessageInfo.Status.READ
+};
+//=======================================================//
+export const getStatusFromReceiptType = (type) => {
+  const status = STATUS_MAP[type];
+  if (typeof type === "undefined") {
+    return proto.WebMessageInfo.Status.DELIVERY_ACK;
+  }
+  return status;
+};
+//=======================================================//
+const CODE_MAP = {
+  conflict: DisconnectReason.connectionReplaced
+};
+//=======================================================//
+export const getErrorCodeFromStreamError = (node) => {
+  const [reasonNode] = getAllBinaryNodeChildren(node);
+  let reason = reasonNode?.tag || "unknown";
+  const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession);
+  if (statusCode === DisconnectReason.restartRequired) {
+    reason = "restart required";
+  }
+  return {
+    reason,
+    statusCode
+  };
+};
+//=======================================================//
+export const getCallStatusFromNode = ({ tag, attrs }) => {
+  let status;
+  switch (tag) {
+    case "offer":
+    case "offer_notice":
+      status = "offer";
+      break;
+    case "terminate":
+      if (attrs.reason === "timeout") {
+        status = "timeout";
+      }
+      else {
+        status = "terminate";
+      }
+      break;
+    case "reject":
+      status = "reject";
+      break;
+    case "accept":
+      status = "accept";
+      break;
+    default:
+      status = "ringing";
+      break;
+  }
+  return status;
+};
+//=======================================================//
+const UNEXPECTED_SERVER_CODE_TEXT = "Unexpected server response: ";
+export const getCodeFromWSError = (error) => {
+  let statusCode = 500;
+  if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
+    const code = +error?.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length);
+    if (!Number.isNaN(code) && code >= 400) {
+      statusCode = code;
+    }
+  }
+  else if (
+  error?.code?.startsWith("E") ||
+    error?.message?.includes("timed out")) {
+    statusCode = 408;
+  }
+  return statusCode;
+};
+//=======================================================//
+export const isWABusinessPlatform = (platform) => {
+  return platform === "smbi" || platform === "smba";
+};
+//=======================================================//
+export function trimUndefined(obj) {
+  for (const key in obj) {
+    if (typeof obj[key] === "undefined") {
+      delete obj[key];
+    }
+  }
+  return obj;
+}
+//=======================================================//
+const CROCKFORD_CHARACTERS = "123456789ABCDEFGHJKLMNPQRSTVWXYZ";
+export function bytesToCrockford(buffer) {
+  let value = 0;
+  let bitCount = 0;
+  const crockford = [];
+  for (const element of buffer) {
+    value = (value << 8) | (element & 0xff);
+    bitCount += 8;
+    while (bitCount >= 5) {
+      crockford.push(CROCKFORD_CHARACTERS.charAt((value >>> (bitCount - 5)) & 31));
+      bitCount -= 5;
+    }
+  }
+  if (bitCount > 0) {
+    crockford.push(CROCKFORD_CHARACTERS.charAt((value << (5 - bitCount)) & 31));
+  }
+  return crockford.join("");
+}
+//=======================================================//
+export function encodeNewsletterMessage(message) {
+  return proto.Message.encode(message).finish();
+}
+//=======================================================//

package/lib/Utils/history.js

@@ -0,0 +1,87 @@
+//=======================================================// 
+import { downloadContentFromMessage } from "./messages-media.js";
+import { normalizeMessageContent } from "./messages.js";
+import { WAMessageStubType } from "../Types/index.js";
+import { proto } from "../../WAProto/index.js";
+import { toNumber } from "./generics.js";
+import { promisify } from "util";
+import { inflate } from "zlib";
+//=======================================================//
+const inflatePromise = promisify(inflate);
+export const downloadHistory = async (msg, options) => {
+  const stream = await downloadContentFromMessage(msg, "md-msg-hist", { options });
+  const bufferArray = [];
+  for await (const chunk of stream) {
+    bufferArray.push(chunk);
+  }
+  let buffer = Buffer.concat(bufferArray);
+  buffer = await inflatePromise(buffer);
+  const syncData = proto.HistorySync.decode(buffer);
+  return syncData;
+};
+//=======================================================//
+export const processHistoryMessage = (item) => {
+  const messages = [];
+  const contacts = [];
+  const chats = [];
+  switch (item.syncType) {
+    case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+    case proto.HistorySync.HistorySyncType.RECENT:
+    case proto.HistorySync.HistorySyncType.FULL:
+    case proto.HistorySync.HistorySyncType.ON_DEMAND:
+      for (const chat of item.conversations) {
+        contacts.push({
+          id: chat.id,
+          name: chat.name || undefined,
+          lid: chat.lidJid || undefined,
+          phoneNumber: chat.pnJid || undefined
+        });
+        const msgs = chat.messages || [];
+        delete chat.messages;
+        for (const item of msgs) {
+          const message = item.message;
+          messages.push(message);
+          if (!chat.messages?.length) {
+            chat.messages = [{ message }];
+          }
+          if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+            chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
+          }
+          if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+            message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
+            message.messageStubParameters?.[0]) {
+            contacts.push({
+              id: message.key.participant || message.key.remoteJid,
+              verifiedName: message.messageStubParameters?.[0]
+            });
+          }
+        }
+        chats.push({ ...chat });
+      }
+      break;
+    case proto.HistorySync.HistorySyncType.PUSH_NAME:
+      for (const c of item.pushnames) {
+        contacts.push({ id: c.id, notify: c.pushname });
+      }
+      break;
+  }
+  return {
+    chats,
+    contacts,
+    messages,
+    syncType: item.syncType,
+    progress: item.progress
+  };
+};
+//=======================================================//
+export const downloadAndProcessHistorySyncNotification = async (msg, options) => {
+  const historyMsg = await downloadHistory(msg, options);
+  return processHistoryMessage(historyMsg);
+};
+//=======================================================//
+export const getHistoryMsg = (message) => {
+  const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
+  const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
+  return anyHistoryMsg;
+};
+//=======================================================//

package/lib/Utils/index.js

@@ -0,0 +1,21 @@
+//=======================================================//
+export * from "./use-multi-file-auth-state.js";
+export * from "./message-retry-manager.js";
+export * from "./baileys-event-stream.js";
+export * from "./validate-connection.js";
+export * from "./decode-wa-message.js";
+export * from "./process-message.js";
+export * from "./messages-media.js";
+export * from "./noise-handler.js";
+export * from "./browser-utils.js";
+export * from "./link-preview.js";
+export * from "./event-buffer.js";
+export * from "./auth-utils.js";
+export * from "./chat-utils.js";
+export * from "./generics.js";
+export * from "./messages.js";
+export * from "./history.js";
+export * from "./lt-hash.js";
+export * from "./crypto.js";
+export * from "./signal.js";
+//=======================================================//

package/lib/Utils/link-preview.js

@@ -0,0 +1,81 @@
+//=======================================================//
+import { extractImageThumb, getHttpStream } from "./messages-media.js";
+import { prepareWAMessageMedia } from "./messages.js";
+//=======================================================//
+const THUMBNAIL_WIDTH_PX = 192;
+//=======================================================//
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+  const stream = await getHttpStream(url, fetchOpts);
+  const result = await extractImageThumb(stream, thumbnailWidth);
+  return result;
+};
+//=======================================================//
+export const getUrlInfo = async (text, opts = {
+  thumbnailWidth: THUMBNAIL_WIDTH_PX,
+  fetchOpts: { timeout: 3000 }
+}) => {
+  try {
+    const retries = 0;
+    const maxRetry = 5;
+    const { getLinkPreview } = await import("link-preview-js");
+    let previewLink = text;
+    if (!text.startsWith("https://") && !text.startsWith("http://")) {
+      previewLink = "https://" + previewLink;
+    }
+    const info = await getLinkPreview(previewLink, {
+      ...opts.fetchOpts,
+      followRedirects: "follow",
+      handleRedirects: (baseURL, forwardedURL) => {
+        const urlObj = new URL(baseURL);
+        const forwardedURLObj = new URL(forwardedURL);
+        if (retries >= maxRetry) {
+          return false;
+        }
+        if (forwardedURLObj.hostname === urlObj.hostname ||
+          forwardedURLObj.hostname === "www." + urlObj.hostname ||
+          "www." + forwardedURLObj.hostname === urlObj.hostname) {
+          retries + 1;
+          return true;
+        }
+        else {
+          return false;
+        }
+      },
+      headers: opts.fetchOpts?.headers
+    });
+    if (info && "title" in info && info.title) {
+      const [image] = info.images;
+      const urlInfo = {
+        "canonical-url": info.url,
+        "matched-text": text,
+        title: info.title,
+        description: info.description,
+        originalThumbnailUrl: image
+      };
+      if (opts.uploadImage) {
+        const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
+          upload: opts.uploadImage,
+          mediaTypeOverride: "thumbnail-link",
+          options: opts.fetchOpts
+        });
+        urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+        urlInfo.highQualityThumbnail = imageMessage || undefined;
+      }
+      else {
+        try {
+          urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
+        }
+        catch (error) {
+          opts.logger?.debug({ err: error.stack, url: previewLink }, "error in generating thumbnail");
+        }
+      }
+      return urlInfo;
+    }
+  }
+  catch (error) {
+    if (!error.message.includes("receive a valid")) {
+      throw error;
+    }
+  }
+};
+//=======================================================//

package/lib/Utils/logger.js

@@ -0,0 +1,5 @@
+//=======================================================//
+import P from "pino";
+//=======================================================//
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+//=======================================================//

package/lib/Utils/lt-hash.js

@@ -0,0 +1,45 @@
+//=======================================================//
+import { hkdf } from "./crypto.js";
+//=======================================================//
+const o = 128;
+class LTHash {
+  constructor(e) {
+    this.salt = e;
+  }
+  async add(e, t) {
+    for (const item of t) {
+      e = await this._addSingle(e, item);
+    }
+    return e;
+  }
+  async subtract(e, t) {
+    for (const item of t) {
+      e = await this._subtractSingle(e, item);
+    }
+    return e;
+  }
+  async subtractThenAdd(e, addList, subtractList) {
+    const subtracted = await this.subtract(e, subtractList);
+    return this.add(subtracted, addList);
+  }
+  async _addSingle(e, t) {
+    const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
+    return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
+  }
+  async _subtractSingle(e, t) {
+    const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
+    return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
+  }
+  performPointwiseWithOverflow(e, t, op) {
+    const n = new DataView(e);
+    const i = new DataView(t);
+    const out = new ArrayBuffer(n.byteLength);
+    const s = new DataView(out);
+    for (let offset = 0; offset < n.byteLength; offset += 2) {
+      s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
+    }
+    return out;
+  }
+}
+export const LT_HASH_ANTI_TAMPERING = new LTHash("WhatsApp Patch Integrity");
+//=======================================================//

package/lib/Utils/make-mutex.js

@@ -0,0 +1,36 @@
+//=======================================================//
+export const makeMutex = () => {
+  let task = Promise.resolve();
+  let taskTimeout;
+  return {
+    mutex(code) {
+      task = (async () => {
+        try {
+          await task;
+        }
+        catch { }
+        try {
+          const result = await code();
+          return result;
+        }
+        finally {
+          clearTimeout(taskTimeout);
+        }
+      })();
+      return task;
+    }
+  };
+};
+//=======================================================//
+export const makeKeyedMutex = () => {
+  const map = {};
+  return {
+    mutex(key, task) {
+      if (!map[key]) {
+        map[key] = makeMutex();
+      }
+      return map[key].mutex(task);
+    }
+  };
+};
+//=======================================================//