@mrlegendbot/baileys 1.2.1 → 1.2.4

package/lib/Utils/signal.js

@@ -3,199 +3,246 @@ import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getB
 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;
+  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)
-    };
+  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 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();
-        }
+  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,
-        lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
-    };
+  }
+  return {
+    newPreKeys,
+    lastPreKeyId,
+    preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+  };
 };
-export const xmppSignedPreKey = (key) => ({
-    tag: 'skey',
+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: [
-        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
-        { tag: 'value', attrs: {}, content: key.keyPair.public },
-        { tag: 'signature', attrs: {}, content: key.signature }
-    ]
+    content: key.signature
+  }]
 });
 export const xmppPreKey = (pair, id) => ({
-    tag: 'key',
+  tag: 'key',
+  attrs: {},
+  content: [{
+    tag: 'id',
     attrs: {},
-    content: [
-        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
-        { tag: 'value', attrs: {}, content: pair.public }
-    ]
+    content: encodeBigEndian(id, 3)
+  }, {
+    tag: 'value',
+    attrs: {},
+    content: pair.public
+  }]
 });
-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) };
+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;
     }
-    return {
-        registrationId,
-        identityKey: generateSignalPubKey(identity),
-        signedPreKey: {
-            keyId: signedKeyId,
-            publicKey: generateSignalPubKey(signedPubKey),
-            signature: signedSig
-        },
-        preKey
+    preKey = {
+      keyId: preKeyId,
+      publicKey: generateSignalPubKey(preKeyPub)
     };
+  }
+  return {
+    registrationId,
+    identityKey: generateSignalPubKey(identity),
+    signedPreKey: {
+      keyId: signedKeyId,
+      publicKey: generateSignalPubKey(signedPubKey),
+      signature: signedSig
+    },
+    preKey
+  };
 };
 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,
-                session: {
-                    registrationId: registrationId,
-                    identityKey: generateSignalPubKey(identity),
-                    signedPreKey: extractKey(signedKey),
-                    preKey: extractKey(key)
-                }
-            });
+  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);
+  }
+  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,
+        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) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-            ) {
-                if (isHosted) {
-                    domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
-                }
-                extracted.push({
-                    user,
-                    device,
-                    domainType,
-                    server: getServerFromDomainType(server, domainType)
-                });
-            }
+  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) && (myUser !== user && myLid !== user || myDevice !== device) && (device === 0 || !!keyIndex)) {
+        if (isHosted) {
+          domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
         }
+        extracted.push({
+          user,
+          device,
+          domainType,
+          server: getServerFromDomainType(server, domainType)
+        });
+      }
     }
-    return extracted;
+  }
+  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, preKeys };
+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,
+    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, node };
+  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,
+    node
+  };
 };
-//# sourceMappingURL=signal.js.map

package/lib/Utils/stanza-ack.js

@@ -1,38 +1,30 @@
-/**
- * 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();
+  const {
+    tag,
+    attrs
+  } = node;
+  const stanza = {
+    tag: 'ack',
+    attrs: {
+      id: attrs.id,
+      to: attrs.from,
+      class: tag
     }
-    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;
+  };
+  if (errorCode) {
+    stanza.attrs.error = errorCode.toString();
+  }
+  if (attrs.participant) {
+    stanza.attrs.participant = attrs.participant;
+  }
+  if (attrs.recipient) {
+    stanza.attrs.recipient = attrs.recipient;
+  }
+  if (attrs.type) {
+    stanza.attrs.type = attrs.type;
+  }
+  if (tag === 'message' && meId) {
+    stanza.attrs.from = meId;
+  }
+  return stanza;
 }
-//# sourceMappingURL=stanza-ack.js.map

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

@@ -1,49 +1,45 @@
-import { proto } from '../../WAProto/index.js';
+import { proto } from '../../WAProto/compiler.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
+  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);
+  const phoneNumber = idIsPn ? id : action.pnJid || undefined;
+  results.push({
+    event: 'contacts.upsert',
+    data: [{
+      id,
+      name: action.fullName || action.firstName || action.username || undefined,
+      username: action.username || undefined,
+      lid: lidJid || undefined,
+      phoneNumber
+    }]
+  });
+  if (lidJid && isLidUser(lidJid) && idIsPn) {
     results.push({
-        event: 'contacts.upsert',
-        data: [
-            {
-                id,
-                name: action.fullName || action.firstName || action.username || undefined,
-                username: action.username || undefined,
-                lid: lidJid || undefined,
-                phoneNumber
-            }
-        ]
+      event: 'lid-mapping.update',
+      data: {
+        lid: lidJid,
+        pn: id
+      }
     });
-    // 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;
+  }
+  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);
-        }
+  for (const result of results) {
+    if (result.event === 'contacts.upsert') {
+      ev.emit('contacts.upsert', result.data);
+    } else {
+      ev.emit('lid-mapping.update', result.data);
     }
+  }
 };
-//# sourceMappingURL=sync-action-utils.js.map