@prototypevip/baileys 0.0.1

package/lib/Utils/generics.js

@@ -0,0 +1,438 @@
+import { Boom } from "@hapi/boom";
+import { createHash, randomBytes } from "crypto";
+import { proto } from "../../WAProto/index.js";
+import { DEFAULT_CONNECTION_CONFIG as config } from "../Defaults/index.js";
+const baileysVersion = [2, 3e3, 1035194821];
+import { DisconnectReason } from "../Types/index.js";
+import {
+  getAllBinaryNodeChildren,
+  jidDecode,
+  isPnUser,
+  isLidUser,
+  isHostedPnUser,
+  isHostedLidUser,
+  jidNormalizedUser,
+} from "../WABinary/index.js";
+import { sha256 } from "./crypto.js";
+
+export const resolveJID = (jid, lidMapping) => {
+  if (!jid || typeof jid !== "string") return jid;
+  if (isPnUser(jid) || isHostedPnUser(jid)) {
+    return jidNormalizedUser(jid);
+  }
+  if (isLidUser(jid) || isHostedLidUser(jid)) {
+    const pn = lidMapping?.getPNForLIDSync(jid);
+    if (pn) return jidNormalizedUser(pn);
+  }
+  return jidNormalizedUser(jid);
+};
+
+export const BufferJSON = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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;
+  },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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) =>
+  (key?.fromMe
+    ? meId
+    : key?.participant ||
+      key?.remoteJid ||
+      key?.participantAlt ||
+      key?.remoteJidAlt) || "";
+export const isStringNullOrEmpty = (value) =>
+  // eslint-disable-next-line eqeqeq
+  value == null || value === "";
+export const writeRandomPadMax16 = (msg) => {
+  const pad = randomBytes(1);
+  const padLength = (pad[0] & 15) + 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);
+};
+// code is inspired by whatsmeow
+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;
+/** unix timestamp of a date in seconds */ export const unixTimestampSeconds = (
+  date = Date.now(),
+) => (date / 1e3) | 0; // Changed from new Date → Date.now for faster operation
+export const debouncedTimeout = (intervalMs = 1e3, 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: stack } }));
+  };
+  return { delay: delay, cancel: cancel };
+};
+export async function promiseTimeout(ms, promise) {
+  if (!ms) {
+    return new Promise(promise);
+  }
+  const stack = new Error().stack;
+  // Create a promise that rejects in <ms> milliseconds
+  const { delay, cancel } = delayCancellable(ms);
+  const p = new Promise((resolve, reject) => {
+    delay
+      .then(() =>
+        reject(
+          new Boom("Timed Out", {
+            statusCode: DisconnectReason.timedOut,
+            data: { stack: stack },
+          }),
+        ),
+      )
+      .catch((err) => reject(err));
+    promise(resolve, reject);
+  }).finally(cancel);
+  return p;
+}
+// inspired from whatsmeow code
+// https://github.com/tulir/whatsmeow/blob/64bc969fbe78d31ae0dd443b8d4c80a5d026d07a/send.go#L42
+export const generateMessageIDV2 = (userId) => {
+  const idFromConfig =
+    typeof config.generateMessageIDV2 === "function"
+      ? config.generateMessageIDV2(userId)
+      : null;
+
+  if (typeof idFromConfig === "string" && idFromConfig) {
+    return idFromConfig;
+  }
+
+  const data = Buffer.allocUnsafe(8 + 20 + 16);
+  data.writeBigUInt64BE(BigInt(unixTimestampSeconds()));
+
+  if (userId) {
+    const id = jidDecode(userId);
+    if (id?.user) {
+      const len = data.write(id.user, 8);
+      data.write("@c.us", 8 + len);
+    }
+  }
+
+  randomBytes(16).copy(data, 28);
+  const hash = createHash("sha256").update(data).digest();
+  const hex = hash.toString("hex").toUpperCase();
+  return hex.substring(0, 32);
+};
+
+export const generateMessageID = () => {
+  const idFromConfig =
+    typeof config.generateMessageID === "function"
+      ? config.generateMessageID()
+      : null;
+
+  if (typeof idFromConfig === "string" && idFromConfig) {
+    return idFromConfig;
+  }
+
+  return randomBytes(32).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");
+/**
+ * utility that fetches latest baileys version from the master branch.
+ * Use to ensure your WA connection is always on the latest version
+ */ export const fetchLatestBaileysVersion = async (options = {}) => {
+  const URL =
+    "https://raw.githubusercontent.com/whiskeysockets/baileys/master/src/Defaults/baileys-version.json";
+  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 json = await response.json();
+    if (Array.isArray(json.version)) {
+      return { version: json.version, isLatest: true };
+    } else {
+      throw new Error("Could not get baileys version");
+    }
+  } catch (error) {
+    return { version: baileysVersion, isLatest: false, error: error };
+  }
+};
+/**
+ * A utility that fetches the latest web version of whatsapp.
+ * Use to ensure your WA connection is always on the latest version
+ */ export const fetchLatestWaWebVersion = async (options = {}) => {
+  try {
+    // Absolute minimal headers required to bypass anti-bot detection
+    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: 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: baileysVersion,
+        isLatest: false,
+        error: {
+          message: "Could not find client revision in the fetched content",
+        },
+      };
+    }
+    const clientRevision = match[1];
+    return { version: [2, 3e3, +clientRevision], isLatest: true };
+  } catch (error) {
+    return { version: baileysVersion, isLatest: false, error: error };
+  }
+};
+/** unique message tag prefix for MD clients */ 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,
+};
+/**
+ * Given a type of receipt, returns what the new status of the message should be
+ * @param type type from receipt
+ */ 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 };
+/**
+ * Stream errors generally provide a reason, map that to a baileys DisconnectReason
+ * @param reason the string reason given, eg. "conflict"
+ */ 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: reason, statusCode: 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 {
+        //fired when accepted/rejected/timeout/caller hangs up
+        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 (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error?.code?.startsWith("E") ||
+    error?.message?.includes("timed out")
+  ) {
+    // handle ETIMEOUT, ENOTFOUND etc
+    statusCode = 408;
+  }
+  return statusCode;
+};
+/**
+ * Is the given platform WA business
+ * @param platform AuthenticationCreds.platform
+ */ export const isWABusinessPlatform = (platform) => {
+  return platform === "smbi" || platform === "smba";
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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 & 255);
+    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,147 @@
+import { pipeline } from "stream/promises";
+import { promisify } from "util";
+import { createInflate, inflate } from "zlib";
+import { proto } from "../../WAProto/index.js";
+import { WAMessageStubType } from "../Types/index.js";
+import {
+  isHostedLidUser,
+  isHostedPnUser,
+  isLidUser,
+  isPnUser,
+} from "../WABinary/index.js";
+import { toNumber } from "./generics.js";
+import { normalizeMessageContent } from "./messages.js";
+import { downloadContentFromMessage } from "./messages-media.js";
+const inflatePromise = promisify(inflate);
+const extractPnFromMessages = (messages) => {
+  for (const msgItem of messages) {
+    const message = msgItem.message;
+    if (!message?.key?.fromMe || !message.userReceipt?.length) {
+      continue;
+    }
+    const userJid = message.userReceipt[0]?.userJid;
+    if (userJid && (isPnUser(userJid) || isHostedPnUser(userJid))) {
+      return userJid;
+    }
+  }
+  return undefined;
+};
+export const downloadHistory = async (msg, options) => {
+  const stream = await downloadContentFromMessage(msg, "md-msg-hist", {
+    options,
+  });
+  const inflater = createInflate();
+  const chunks = [];
+  inflater.on("data", (chunk) => chunks.push(chunk));
+  await pipeline(stream, inflater);
+  const buffer = Buffer.concat(chunks);
+  const syncData = proto.HistorySync.decode(buffer);
+  return syncData;
+};
+export const processHistoryMessage = (item, logger) => {
+  const messages = [];
+  const contacts = [];
+  const chats = [];
+  const lidPnMappings = [];
+  logger?.trace(
+    { progress: item.progress },
+    "processing history of type " + item.syncType?.toString(),
+  );
+  for (const m of item.phoneNumberToLidMappings || []) {
+    if (m.lidJid && m.pnJid) {
+      lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
+    }
+  }
+  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.displayName || chat.name || chat.username || undefined,
+          username: chat.username || undefined,
+          lid: chat.lidJid || chat.accountLid || undefined,
+          phoneNumber: chat.pnJid || undefined,
+        });
+        const chatId = chat.id;
+        const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
+        const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
+        if (isLid && chat.pnJid) {
+          lidPnMappings.push({ lid: chatId, pn: chat.pnJid });
+        } else if (isPn && chat.lidJid) {
+          lidPnMappings.push({ lid: chat.lidJid, pn: chatId });
+        } else if (isLid && !chat.pnJid) {
+          const pnFromReceipt = extractPnFromMessages(chat.messages || []);
+          if (pnFromReceipt) {
+            lidPnMappings.push({ lid: chatId, pn: pnFromReceipt });
+          }
+        }
+        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,
+    lidPnMappings,
+    nctSalt: item.nctSalt,
+    pastParticipants: item.pastParticipants,
+    syncType: item.syncType,
+    progress: item.progress,
+  };
+};
+export const downloadAndProcessHistorySyncNotification = async (
+  msg,
+  options,
+  logger,
+) => {
+  let historyMsg;
+  if (msg.initialHistBootstrapInlinePayload) {
+    historyMsg = proto.HistorySync.decode(
+      await inflatePromise(msg.initialHistBootstrapInlinePayload),
+    );
+  } else {
+    historyMsg = await downloadHistory(msg, options);
+  }
+  return processHistoryMessage(historyMsg, logger);
+};
+export const getHistoryMsg = (message) => {
+  const normalizedContent = !!message
+    ? normalizeMessageContent(message)
+    : undefined;
+  const anyHistoryMsg =
+    normalizedContent?.protocolMessage?.historySyncNotification;
+  return anyHistoryMsg;
+};

package/lib/Utils/identity-change-handler.js

@@ -0,0 +1,63 @@
+import NodeCache from "@cacheable/node-cache";
+import {
+  areJidsSameUser,
+  getBinaryNodeChild,
+  jidDecode,
+} from "../WABinary/index.js";
+import { isStringNullOrEmpty } from "./generics.js";
+export async function handleIdentityChange(node, ctx) {
+  const from = node.attrs.from;
+  if (!from) {
+    return { action: "invalid_notification" };
+  }
+  const identityNode = getBinaryNodeChild(node, "identity");
+  if (!identityNode) {
+    return { action: "no_identity_node" };
+  }
+  ctx.logger.info({ jid: from }, "identity changed");
+  const decoded = jidDecode(from);
+  if (decoded?.device && decoded.device !== 0) {
+    ctx.logger.debug(
+      { jid: from, device: decoded.device },
+      "ignoring identity change from companion device",
+    );
+    return { action: "skipped_companion_device", device: decoded.device };
+  }
+  const isSelfPrimary =
+    ctx.meId &&
+    (areJidsSameUser(from, ctx.meId) ||
+      (ctx.meLid && areJidsSameUser(from, ctx.meLid)));
+  if (isSelfPrimary) {
+    ctx.logger.info({ jid: from }, "self primary identity changed");
+    return { action: "skipped_self_primary" };
+  }
+  if (ctx.debounceCache.get(from)) {
+    ctx.logger.debug({ jid: from }, "skipping identity assert (debounced)");
+    return { action: "debounced" };
+  }
+  ctx.debounceCache.set(from, true);
+  const isOfflineNotification = !isStringNullOrEmpty(node.attrs.offline);
+  const hasExistingSession = await ctx.validateSession(from);
+  if (!hasExistingSession.exists) {
+    ctx.logger.debug({ jid: from }, "no old session, skipping session refresh");
+    return { action: "skipped_no_session" };
+  }
+  ctx.logger.debug({ jid: from }, "old session exists, will refresh session");
+  if (isOfflineNotification) {
+    ctx.logger.debug(
+      { jid: from },
+      "skipping session refresh during offline processing",
+    );
+    return { action: "skipped_offline" };
+  }
+  try {
+    await ctx.assertSessions([from], true);
+    return { action: "session_refreshed" };
+  } catch (error) {
+    ctx.logger.warn(
+      { error: error, jid: from },
+      "failed to assert sessions after identity change",
+    );
+    return { action: "session_refresh_failed", error: error };
+  }
+}

package/lib/Utils/index.js

@@ -0,0 +1,29 @@
+export * from "./make-mutex.js";
+export * from "./generics.js";
+export * from "./decode-wa-message.js";
+export * from "./messages.js";
+export * from "./messages-media.js";
+export * from "./validate-connection.js";
+export * from "./crypto.js";
+export * from "./signal.js";
+export * from "./noise-handler.js";
+export * from "./history.js";
+export * from "./chat-utils.js";
+export * from "./lt-hash.js";
+export * from "./auth-utils.js";
+export * from "./use-multi-file-auth-state.js";
+export * from "./use-single-file-auth-state.js";
+export * from "./link-preview.js";
+export * from "./event-buffer.js";
+export * from "./process-message.js";
+export * from "./message-retry-manager.js";
+export * from "./browser-utils.js";
+export * from "./companion-reg-client-utils.js";
+export * from "./identity-change-handler.js";
+export * from "./stanza-ack.js";
+export * from "./tc-token-utils.js";
+export * from "./cstoken-utils.js";
+export * from "./use-prototype-auth-state.js";
+export * from "./sticker-utils.js";
+export * from "./rich-message-utils.js";
+export * from "./constants.js";