@sgintokic/baileys 0.0.2

package/lib/Utils/reporting-utils.js

@@ -0,0 +1,346 @@
+import { createHmac } from "crypto";
+import { proto } from "../../WAProto/index.js";
+import { hkdf } from "./crypto.js";
+const reportingFields = [
+  { f: 1 },
+  {
+    f: 3,
+    s: [
+      { f: 2 },
+      { f: 3 },
+      { f: 8 },
+      { f: 11 },
+      { f: 17, s: [{ f: 21 }, { f: 22 }] },
+      { f: 25 },
+    ],
+  },
+  { f: 4, s: [{ f: 1 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+  {
+    f: 5,
+    s: [
+      { f: 3 },
+      { f: 4 },
+      { f: 5 },
+      { f: 16 },
+      { f: 17, s: [{ f: 21 }, { f: 22 }] },
+    ],
+  },
+  { f: 6, s: [{ f: 1 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 30 }] },
+  {
+    f: 7,
+    s: [
+      { f: 2 },
+      { f: 7 },
+      { f: 10 },
+      { f: 17, s: [{ f: 21 }, { f: 22 }] },
+      { f: 20 },
+    ],
+  },
+  {
+    f: 8,
+    s: [
+      { f: 2 },
+      { f: 7 },
+      { f: 9 },
+      { f: 17, s: [{ f: 21 }, { f: 22 }] },
+      { f: 21 },
+    ],
+  },
+  {
+    f: 9,
+    s: [
+      { f: 2 },
+      { f: 6 },
+      { f: 7 },
+      { f: 13 },
+      { f: 17, s: [{ f: 21 }, { f: 22 }] },
+      { f: 20 },
+    ],
+  },
+  { f: 12, s: [{ f: 1 }, { f: 2 }, { f: 14, m: true }, { f: 15 }] },
+  { f: 18, s: [{ f: 6 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+  {
+    f: 26,
+    s: [
+      { f: 4 },
+      { f: 5 },
+      { f: 8 },
+      { f: 13 },
+      { f: 17, s: [{ f: 21 }, { f: 22 }] },
+    ],
+  },
+  {
+    f: 28,
+    s: [
+      { f: 1 },
+      { f: 2 },
+      { f: 4 },
+      { f: 5 },
+      { f: 6 },
+      { f: 7, s: [{ f: 21 }, { f: 22 }] },
+    ],
+  },
+  { f: 37, s: [{ f: 1, m: true }] },
+  {
+    f: 49,
+    s: [
+      { f: 2 },
+      { f: 3, s: [{ f: 1 }, { f: 2 }] },
+      { f: 5, s: [{ f: 21 }, { f: 22 }] },
+      { f: 8, s: [{ f: 1 }, { f: 2 }] },
+    ],
+  },
+  { f: 53, s: [{ f: 1, m: true }] },
+  { f: 55, s: [{ f: 1, m: true }] },
+  { f: 58, s: [{ f: 1, m: true }] },
+  { f: 59, s: [{ f: 1, m: true }] },
+  {
+    f: 60,
+    s: [
+      { f: 2 },
+      { f: 3, s: [{ f: 1 }, { f: 2 }] },
+      { f: 5, s: [{ f: 21 }, { f: 22 }] },
+      { f: 8, s: [{ f: 1 }, { f: 2 }] },
+    ],
+  },
+  {
+    f: 64,
+    s: [
+      { f: 2 },
+      { f: 3, s: [{ f: 1 }, { f: 2 }] },
+      { f: 5, s: [{ f: 21 }, { f: 22 }] },
+      { f: 8, s: [{ f: 1 }, { f: 2 }] },
+    ],
+  },
+  {
+    f: 66,
+    s: [
+      { f: 2 },
+      { f: 6 },
+      { f: 7 },
+      { f: 13 },
+      { f: 17, s: [{ f: 21 }, { f: 22 }] },
+      { f: 20 },
+    ],
+  },
+  { f: 74, s: [{ f: 1, m: true }] },
+  { f: 87, s: [{ f: 1, m: true }] },
+  {
+    f: 88,
+    s: [{ f: 1 }, { f: 2, s: [{ f: 1 }] }, { f: 3, s: [{ f: 21 }, { f: 22 }] }],
+  },
+  { f: 92, s: [{ f: 1, m: true }] },
+  { f: 93, s: [{ f: 1, m: true }] },
+  { f: 94, s: [{ f: 1, m: true }] },
+];
+const compileReportingFields = (fields) => {
+  const map = new Map();
+  for (const f of fields) {
+    map.set(f.f, {
+      m: f.m,
+      children: f.s ? compileReportingFields(f.s) : undefined,
+    });
+  }
+  return map;
+};
+const compiledReportingFields = compileReportingFields(reportingFields);
+const EMPTY_MAP = new Map();
+const ENC_SECRET_REPORT_TOKEN = "Report Token";
+const WIRE = { VARINT: 0, FIXED64: 1, BYTES: 2, FIXED32: 5 };
+export const shouldIncludeReportingToken = (message) =>
+  !message.reactionMessage &&
+  !message.encReactionMessage &&
+  !message.encEventResponseMessage &&
+  !message.pollUpdateMessage;
+const generateMsgSecretKey = (
+  modificationType,
+  origMsgId,
+  origMsgSender,
+  modificationSender,
+  origMsgSecret,
+) => {
+  const useCaseSecret = Buffer.concat([
+    Buffer.from(origMsgId, "utf8"),
+    Buffer.from(origMsgSender, "utf8"),
+    Buffer.from(modificationSender, "utf8"),
+    Buffer.from(modificationType, "utf8"),
+  ]);
+  return hkdf(origMsgSecret, 32, { info: useCaseSecret.toString("latin1") });
+};
+const extractReportingTokenContent = (data, cfg) => {
+  const out = [];
+  let i = 0;
+  while (i < data.length) {
+    const tag = decodeVarint(data, i);
+    if (!tag.ok) {
+      return null;
+    }
+    const fieldNum = tag.value >> 3;
+    const wireType = tag.value & 7;
+    const fieldStart = i;
+    i += tag.bytes;
+    const fieldCfg = cfg.get(fieldNum);
+    const pushSlice = (end) => {
+      if (end > data.length) {
+        return false;
+      }
+      out.push({ num: fieldNum, bytes: data.subarray(fieldStart, end) });
+      i = end;
+      return true;
+    };
+    const skip = (end) => {
+      if (end > data.length) {
+        return false;
+      }
+      i = end;
+      return true;
+    };
+    if (wireType === WIRE.VARINT) {
+      const v = decodeVarint(data, i);
+      if (!v.ok) {
+        return null;
+      }
+      const end = i + v.bytes;
+      if (!fieldCfg) {
+        if (!skip(end)) {
+          return null;
+        }
+        continue;
+      }
+      if (!pushSlice(end)) {
+        return null;
+      }
+      continue;
+    }
+    if (wireType === WIRE.FIXED64) {
+      const end = i + 8;
+      if (!fieldCfg) {
+        if (!skip(end)) {
+          return null;
+        }
+        continue;
+      }
+      if (!pushSlice(end)) {
+        return null;
+      }
+      continue;
+    }
+    if (wireType === WIRE.FIXED32) {
+      const end = i + 4;
+      if (!fieldCfg) {
+        if (!skip(end)) {
+          return null;
+        }
+        continue;
+      }
+      if (!pushSlice(end)) {
+        return null;
+      }
+      continue;
+    }
+    if (wireType === WIRE.BYTES) {
+      const len = decodeVarint(data, i);
+      if (!len.ok) {
+        return null;
+      }
+      const valStart = i + len.bytes;
+      const valEnd = valStart + len.value;
+      if (valEnd > data.length) {
+        return null;
+      }
+      if (!fieldCfg) {
+        i = valEnd;
+        continue;
+      }
+      if (fieldCfg.m || fieldCfg.children) {
+        const sub = extractReportingTokenContent(
+          data.subarray(valStart, valEnd),
+          fieldCfg.children ?? EMPTY_MAP,
+        );
+        if (sub === null) {
+          return null;
+        }
+        if (sub.length > 0) {
+          const newTag = encodeVarint(tag.value);
+          const newLen = encodeVarint(sub.length);
+          out.push({
+            num: fieldNum,
+            bytes: Buffer.concat([newTag, newLen, sub]),
+          });
+        }
+        i = valEnd;
+        continue;
+      }
+      out.push({ num: fieldNum, bytes: data.subarray(fieldStart, valEnd) });
+      i = valEnd;
+      continue;
+    }
+    return null;
+  }
+  if (out.length === 0) {
+    return Buffer.alloc(0);
+  }
+  out.sort((a, b) => a.num - b.num);
+  return Buffer.concat(out.map((f) => f.bytes));
+};
+const decodeVarint = (buffer, offset) => {
+  let value = 0;
+  let bytes = 0;
+  let shift = 0;
+  while (offset + bytes < buffer.length) {
+    const current = buffer[offset + bytes];
+    value |= (current & 127) << shift;
+    bytes++;
+    if ((current & 128) === 0) {
+      return { value: value, bytes: bytes, ok: true };
+    }
+    shift += 7;
+    if (shift > 35) {
+      return { value: 0, bytes: 0, ok: false };
+    }
+  }
+  return { value: 0, bytes: 0, ok: false };
+};
+const encodeVarint = (value) => {
+  const parts = [];
+  let remaining = value >>> 0;
+  while (remaining > 127) {
+    parts.push((remaining & 127) | 128);
+    remaining >>>= 7;
+  }
+  parts.push(remaining);
+  return Buffer.from(parts);
+};
+export const getMessageReportingToken = async (msgProtobuf, message, key) => {
+  const msgSecret = message.messageContextInfo?.messageSecret;
+  if (!msgSecret || !key.id) {
+    return null;
+  }
+  const from = key.fromMe ? key.remoteJid : key.participant || key.remoteJid;
+  const to = key.fromMe ? key.participant || key.remoteJid : key.remoteJid;
+  const reportingSecret = generateMsgSecretKey(
+    ENC_SECRET_REPORT_TOKEN,
+    key.id,
+    from,
+    to,
+    msgSecret,
+  );
+  const content = extractReportingTokenContent(
+    msgProtobuf,
+    compiledReportingFields,
+  );
+  if (!content || content.length === 0) {
+    return null;
+  }
+  const reportingToken = createHmac("sha256", reportingSecret)
+    .update(content)
+    .digest()
+    .subarray(0, 16);
+  return {
+    tag: "reporting",
+    attrs: {},
+    content: [
+      { tag: "reporting_token", attrs: { v: "2" }, content: reportingToken },
+    ],
+  };
+};

package/lib/Utils/signal.js

@@ -0,0 +1,188 @@
+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 };
+};

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/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);
+    }
+  }
+};

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,15 @@
+export async function buildTcTokenFromJid({
+  authState,
+  jid,
+  baseContent = [],
+}) {
+  try {
+    const tcTokenData = await authState.keys.get("tctoken", [jid]);
+    const tcTokenBuffer = tcTokenData?.[jid]?.token;
+    if (!tcTokenBuffer) return baseContent.length > 0 ? baseContent : undefined;
+    baseContent.push({ tag: "tctoken", attrs: {}, content: tcTokenBuffer });
+    return baseContent;
+  } catch (error) {
+    return baseContent.length > 0 ? baseContent : undefined;
+  }
+}