@prototypevip/baileys 0.0.1

package/lib/Utils/signal.js

@@ -0,0 +1,233 @@
+import { KEY_BUNDLE_TYPE } from "../Defaults/index.js";
+import {
+  assertNodeErrorFree,
+  getBinaryNodeChild,
+  getBinaryNodeChildBuffer,
+  getBinaryNodeChildren,
+  getBinaryNodeChildUInt,
+  getServerFromDomainType,
+  jidDecode,
+  S_WHATSAPP_NET,
+  WAJIDDomains,
+} from "../WABinary/index.js";
+import { Curve, generateSignalPubKey } from "./crypto.js";
+import { encodeBigEndian } from "./generics.js";
+function chunk(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+export const createSignalIdentity = (wid, accountSignatureKey) => {
+  return {
+    identifier: { name: wid, deviceId: 0 },
+    identifierKey: generateSignalPubKey(accountSignatureKey),
+  };
+};
+export const getPreKeys = async ({ get }, min, limit) => {
+  const idList = [];
+  for (let id = min; id < limit; id++) {
+    idList.push(id.toString());
+  }
+  return get("pre-key", idList);
+};
+export const generateOrGetPreKeys = (creds, range) => {
+  const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
+  const remaining = range - avaliable;
+  const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
+  const newPreKeys = {};
+  if (remaining > 0) {
+    for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
+      newPreKeys[i] = Curve.generateKeyPair();
+    }
+  }
+  return {
+    newPreKeys: newPreKeys,
+    lastPreKeyId: lastPreKeyId,
+    preKeysRange: [creds.firstUnuploadedPreKeyId, range],
+  };
+};
+export const xmppSignedPreKey = (key) => ({
+  tag: "skey",
+  attrs: {},
+  content: [
+    { tag: "id", attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+    { tag: "value", attrs: {}, content: key.keyPair.public },
+    { tag: "signature", attrs: {}, content: key.signature },
+  ],
+});
+export const xmppPreKey = (pair, id) => ({
+  tag: "key",
+  attrs: {},
+  content: [
+    { tag: "id", attrs: {}, content: encodeBigEndian(id, 3) },
+    { tag: "value", attrs: {}, content: pair.public },
+  ],
+});
+export const parseAndInjectE2ESessions = async (node, repository) => {
+  const extractKey = (key) =>
+    key
+      ? {
+          keyId: getBinaryNodeChildUInt(key, "id", 3),
+          publicKey: generateSignalPubKey(
+            getBinaryNodeChildBuffer(key, "value"),
+          ),
+          signature: getBinaryNodeChildBuffer(key, "signature"),
+        }
+      : undefined;
+  const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, "list"), "user");
+  for (const node of nodes) {
+    assertNodeErrorFree(node);
+  }
+  // Most of the work in repository.injectE2ESession is CPU intensive, not IO
+  // So Promise.all doesn't really help here,
+  // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
+  // This way we chunk it in smaller parts and between those parts we can yield to the event loop
+  // It's rare case when you need to E2E sessions for so many users, but it's possible
+  const chunkSize = 100;
+  const chunks = chunk(nodes, chunkSize);
+  for (const nodesChunk of chunks) {
+    for (const node of nodesChunk) {
+      const signedKey = getBinaryNodeChild(node, "skey");
+      const key = getBinaryNodeChild(node, "key");
+      const identity = getBinaryNodeChildBuffer(node, "identity");
+      const jid = node.attrs.jid;
+      const registrationId = getBinaryNodeChildUInt(node, "registration", 4);
+      await repository.injectE2ESession({
+        jid: jid,
+        session: {
+          registrationId: registrationId,
+          identityKey: generateSignalPubKey(identity),
+          signedPreKey: extractKey(signedKey),
+          preKey: extractKey(key),
+        },
+      });
+    }
+  }
+};
+export const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+  const { user: myUser, device: myDevice } = jidDecode(myJid);
+  const extracted = [];
+  for (const userResult of result) {
+    const { devices, id } = userResult;
+    const decoded = jidDecode(id),
+      { user, server } = decoded;
+    let { domainType } = decoded;
+    const deviceList = devices?.deviceList;
+    if (!Array.isArray(deviceList)) continue;
+    for (const { id: device, keyIndex, isHosted } of deviceList) {
+      if (
+        (!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+        ((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
+        (device === 0 || !!keyIndex)
+      ) {
+        if (isHosted) {
+          domainType =
+            domainType === WAJIDDomains.LID
+              ? WAJIDDomains.HOSTED_LID
+              : WAJIDDomains.HOSTED;
+        }
+        extracted.push({
+          user: user,
+          device: device,
+          domainType: domainType,
+          server: getServerFromDomainType(server, domainType),
+        });
+      }
+    }
+  }
+  return extracted;
+};
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */ export const getNextPreKeys = async ({ creds, keys }, count) => {
+  const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(
+    creds,
+    count,
+  );
+  const update = {
+    nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+    firstUnuploadedPreKeyId: Math.max(
+      creds.firstUnuploadedPreKeyId,
+      lastPreKeyId + 1,
+    ),
+  };
+  await keys.set({ "pre-key": newPreKeys });
+  const preKeys = await getPreKeys(
+    keys,
+    preKeysRange[0],
+    preKeysRange[0] + preKeysRange[1],
+  );
+  return { update: update, preKeys: preKeys };
+};
+export const getNextPreKeysNode = async (state, count) => {
+  const { creds } = state;
+  const { update, preKeys } = await getNextPreKeys(state, count);
+  const node = {
+    tag: "iq",
+    attrs: { xmlns: "encrypt", type: "set", to: S_WHATSAPP_NET },
+    content: [
+      {
+        tag: "registration",
+        attrs: {},
+        content: encodeBigEndian(creds.registrationId),
+      },
+      { tag: "type", attrs: {}, content: KEY_BUNDLE_TYPE },
+      { tag: "identity", attrs: {}, content: creds.signedIdentityKey.public },
+      {
+        tag: "list",
+        attrs: {},
+        content: Object.keys(preKeys).map((k) => xmppPreKey(preKeys[+k], +k)),
+      },
+      xmppSignedPreKey(creds.signedPreKey),
+    ],
+  };
+  return { update: update, node: node };
+};
+
+const isValidUInt = (n) => typeof n === "number" && Number.isInteger(n);
+export const extractE2ESessionFromRetryReceipt = (receipt) => {
+  const keysNode = getBinaryNodeChild(receipt, "keys");
+  if (!keysNode) return null;
+  const typeBuf = getBinaryNodeChildBuffer(keysNode, "type");
+  if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0])
+    return null;
+  const identity = getBinaryNodeChildBuffer(keysNode, "identity");
+  const skey = getBinaryNodeChild(keysNode, "skey");
+  if (!identity || identity.length !== 32 || !skey) return null;
+  const registrationId = getBinaryNodeChildUInt(receipt, "registration", 4);
+  if (!isValidUInt(registrationId)) return null;
+  const signedPubKey = getBinaryNodeChildBuffer(skey, "value");
+  const signedSig = getBinaryNodeChildBuffer(skey, "signature");
+  const signedKeyId = getBinaryNodeChildUInt(skey, "id", 3);
+  if (
+    !signedPubKey ||
+    signedPubKey.length !== 32 ||
+    !signedSig ||
+    !isValidUInt(signedKeyId)
+  ) {
+    return null;
+  }
+  const preKeyNode = getBinaryNodeChild(keysNode, "key");
+  let preKey;
+  if (preKeyNode) {
+    const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, "value");
+    const preKeyId = getBinaryNodeChildUInt(preKeyNode, "id", 3);
+    if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
+      return null;
+    }
+    preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) };
+  }
+  return {
+    registrationId,
+    identityKey: generateSignalPubKey(identity),
+    signedPreKey: {
+      keyId: signedKeyId,
+      publicKey: generateSignalPubKey(signedPubKey),
+      signature: signedSig,
+    },
+    preKey,
+  };
+};

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,33 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node, errorCode, meId) {
+  const { tag, attrs } = node;
+  const stanza = {
+    tag: "ack",
+    attrs: { id: attrs.id, to: attrs.from, class: tag },
+  };
+  if (errorCode) {
+    stanza.attrs.error = errorCode.toString();
+  }
+  if (attrs.participant) {
+    stanza.attrs.participant = attrs.participant;
+  }
+  if (attrs.recipient) {
+    stanza.attrs.recipient = attrs.recipient;
+  }
+  // WA Web always includes type when present: `n.type || DROP_ATTR`
+  if (attrs.type) {
+    stanza.attrs.type = attrs.type;
+  }
+  // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+  if (tag === "message" && meId) {
+    stanza.attrs.from = meId;
+  }
+  return stanza;
+}

package/lib/Utils/sticker-utils.js

@@ -0,0 +1,221 @@
+import { exec } from "child_process";
+import { promises as fs } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { generateMessageIDV2 } from "./generics.js";
+import { getImageProcessingLibrary } from "./messages-media.js";
+
+/**
+ * Add metadata (EXIF) to a WebP buffer
+ */
+export function writeExif(webpBuffer, metadata) {
+  const json = {
+    "sticker-pack-id": metadata.stickerPackId || "",
+    "sticker-pack-name": metadata.packname || "",
+    "sticker-pack-publisher": metadata.author || "",
+    emojis: metadata.categories || [""],
+  };
+
+  const exifAttr = Buffer.from([
+    0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57,
+    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+  ]);
+  const jsonBuff = Buffer.from(JSON.stringify(json));
+  const exifRaw = Buffer.concat([exifAttr, jsonBuff]);
+  exifRaw.writeUInt32LE(jsonBuff.length, 14);
+
+  const exifHeader = Buffer.alloc(8);
+  exifHeader.write("EXIF", 0);
+  exifHeader.writeUInt32LE(exifRaw.length, 4);
+  const exifChunk = Buffer.concat([
+    exifHeader,
+    exifRaw,
+    exifRaw.length % 2 ? Buffer.from([0]) : Buffer.alloc(0),
+  ]);
+
+  let offset = 12;
+  let chunks = [];
+  while (offset < webpBuffer.length - 8) {
+    const chunkFourCC = webpBuffer.toString("ascii", offset, offset + 4);
+    const chunkSize = webpBuffer.readUInt32LE(offset + 4);
+    const totalSize = 8 + chunkSize + (chunkSize % 2);
+    chunks.push({
+      fourCC: chunkFourCC,
+      data: webpBuffer.subarray(offset, offset + totalSize),
+    });
+    offset += totalSize;
+  }
+
+  let vp8x = chunks.find((c) => c.fourCC === "VP8X");
+  if (vp8x) {
+    vp8x.data = Buffer.from(vp8x.data);
+    vp8x.data[8] |= 0b00001000; // Enable EXIF bit
+  } else {
+    let width = 0,
+      height = 0,
+      hasAlpha = false,
+      hasAnim = false;
+    for (const c of chunks) {
+      if (c.fourCC === "VP8 ") {
+        const data = c.data.subarray(8);
+        width = ((data[7] << 8) | data[6]) & 0x3fff;
+        height = ((data[9] << 8) | data[8]) & 0x3fff;
+      } else if (c.fourCC === "VP8L") {
+        const data = c.data.subarray(8);
+        width = (((data[2] & 0x3f) << 8) | data[1]) + 1;
+        height =
+          ((((data[4] << 16) | (data[3] << 8) | data[2]) >> 6) & 0x3fff) + 1;
+        hasAlpha = !!(data[4] & 0x10);
+      } else if (c.fourCC === "ALPH") {
+        hasAlpha = true;
+      } else if (c.fourCC === "ANIM") {
+        hasAnim = true;
+      }
+    }
+
+    const vp8xBuf = Buffer.alloc(18);
+    vp8xBuf.write("VP8X", 0);
+    vp8xBuf.writeUInt32LE(10, 4);
+    let flags = 0b00001000; // EXIF
+    if (hasAlpha) flags |= 0x10;
+    if (hasAnim) flags |= 0x02;
+    vp8xBuf[8] = flags;
+
+    vp8xBuf.writeUIntLE((width || 512) - 1, 12, 3);
+    vp8xBuf.writeUIntLE((height || 512) - 1, 15, 3);
+    vp8x = { fourCC: "VP8X", data: vp8xBuf };
+  }
+
+  const otherChunks = chunks.filter(
+    (c) => c.fourCC !== "VP8X" && c.fourCC !== "EXIF",
+  );
+  const out = Buffer.concat([
+    webpBuffer.subarray(0, 12),
+    vp8x.data,
+    exifChunk,
+    ...otherChunks.map((c) => c.data),
+  ]);
+
+  out.writeUInt32LE(out.length - 8, 4);
+  return out;
+}
+
+/**
+ * Checks if a WebP buffer is animated
+ */
+export const isAnimatedWebP = (buffer) => {
+  if (
+    buffer.length < 12 ||
+    buffer[0] !== 82 ||
+    buffer[1] !== 73 ||
+    buffer[2] !== 70 ||
+    buffer[3] !== 70 ||
+    buffer[8] !== 87 ||
+    buffer[9] !== 69 ||
+    buffer[10] !== 66 ||
+    buffer[11] !== 80
+  ) {
+    return false;
+  }
+  let offset = 12;
+  while (offset < buffer.length - 8) {
+    const chunkFourCC = buffer.toString("ascii", offset, offset + 4);
+    const chunkSize = buffer.readUInt32LE(offset + 4);
+    if (chunkFourCC === "VP8X") {
+      const flagsOffset = offset + 8;
+      if (flagsOffset < buffer.length) {
+        const flags = buffer[flagsOffset];
+        if (flags & 2) {
+          return true;
+        }
+      }
+    } else if (chunkFourCC === "ANIM" || chunkFourCC === "ANMF") {
+      return true;
+    }
+    offset += 8 + chunkSize + (chunkSize % 2);
+  }
+  return false;
+};
+
+/**
+ * Checks if a buffer is a WebP file
+ */
+export const isWebPBuffer = (buffer) => {
+  return (
+    buffer.length >= 12 &&
+    buffer[0] === 82 &&
+    buffer[1] === 73 &&
+    buffer[2] === 70 &&
+    buffer[3] === 70 &&
+    buffer[8] === 87 &&
+    buffer[9] === 69 &&
+    buffer[10] === 66 &&
+    buffer[11] === 80
+  );
+};
+
+/**
+ * Convert media buffer (image, video, sticker) to WebP sticker with EXIF
+ */
+export async function mediaToWebp(buffer, metadata = {}) {
+  const author = metadata.author || "TAKASUGI";
+  const packName = metadata.packName || "SHINSUKE";
+
+  let webpBuffer;
+  const isWebp = isWebPBuffer(buffer);
+  const isAnimated = isWebp && isAnimatedWebP(buffer);
+
+  const lib = await getImageProcessingLibrary();
+
+  if (lib.sharp) {
+    // Try processing with sharp first (handles images and both static/animated webp)
+    try {
+      webpBuffer = await lib
+        .sharp(buffer, isAnimated ? { animated: true } : {})
+        .resize(512, 512, { fit: "inside" })
+        .webp()
+        .toBuffer();
+    } catch (e) {
+      // Fallback to ffmpeg if sharp fails (e.g. video or unsupported format)
+    }
+  }
+
+  if (!webpBuffer) {
+    // Handle as video or unsupported sharp format using ffmpeg
+    const tmpFileIn = join(tmpdir(), `sticker-in-${generateMessageIDV2()}`);
+    const tmpFileOut = join(
+      tmpdir(),
+      `sticker-out-${generateMessageIDV2()}.webp`,
+    );
+
+    await fs.writeFile(tmpFileIn, buffer);
+
+    try {
+      await new Promise((resolve, reject) => {
+        // Optimized ffmpeg command for stickers (max 6s, 512x512, an, contain fit)
+        const ffmpegCmd = `ffmpeg -i ${tmpFileIn} -vcodec libwebp -filter:v "fps=fps=20,scale=512:512:flags=lanczos:force_original_aspect_ratio=decrease,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000" -lossless 1 -loop 0 -preset default -an -vsync 0 -t 6 ${tmpFileOut}`;
+        exec(ffmpegCmd, (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+
+      webpBuffer = await fs.readFile(tmpFileOut);
+    } finally {
+      await Promise.all([
+        fs.unlink(tmpFileIn).catch(() => {}),
+        fs.unlink(tmpFileOut).catch(() => {}),
+      ]);
+    }
+  }
+
+  if (!webpBuffer) {
+    throw new Error("Failed to convert media to WebP");
+  }
+
+  return writeExif(webpBuffer, {
+    author,
+    packname: packName,
+    stickerPackId: generateMessageIDV2(),
+  });
+}

package/lib/Utils/sync-action-utils.js

@@ -0,0 +1,53 @@
+import { proto } from "../../WAProto/index.js";
+import { isLidUser, isPnUser } from "../WABinary/index.js";
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */ export const processContactAction = (action, id, logger) => {
+  const results = [];
+  if (!id) {
+    logger?.warn(
+      {
+        hasFullName: !!action.fullName,
+        hasLidJid: !!action.lidJid,
+        hasPnJid: !!action.pnJid,
+      },
+      "contactAction sync: missing id in index",
+    );
+    return results;
+  }
+  const lidJid = action.lidJid;
+  const idIsPn = isPnUser(id);
+  // PN is in index[1], not in contactAction.pnJid which is usually null
+  const phoneNumber = idIsPn ? id : action.pnJid || undefined;
+  // Always emit contacts.upsert
+  results.push({
+    event: "contacts.upsert",
+    data: [
+      {
+        id: id,
+        name:
+          action.fullName || action.firstName || action.username || undefined,
+        lid: lidJid || undefined,
+        phoneNumber: phoneNumber,
+      },
+    ],
+  });
+  // Emit lid-mapping.update if we have valid LID-PN pair
+  if (lidJid && isLidUser(lidJid) && idIsPn) {
+    results.push({
+      event: "lid-mapping.update",
+      data: { lid: lidJid, pn: id },
+    });
+  }
+  return results;
+};
+export const emitSyncActionResults = (ev, results) => {
+  for (const result of results) {
+    if (result.event === "contacts.upsert") {
+      ev.emit("contacts.upsert", result.data);
+    } else {
+      ev.emit("lid-mapping.update", result.data);
+    }
+  }
+};