@fazzcode/baileys 0.1.7 → 2.0.6

package/lib/Utils/signal.js

@@ -1,151 +1,161 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids = exports.parseAndInjectE2ESessions = exports.xmppPreKey = exports.xmppSignedPreKey = exports.generateOrGetPreKeys = exports.getPreKeys = exports.createSignalIdentity = void 0;
-const Defaults_1 = require("../Defaults");
-const WABinary_1 = require("../WABinary");
-const crypto_1 = require("./crypto");
-const generics_1 = require("./generics");
-const createSignalIdentity = (wid, accountSignatureKey) => {
-    return {
-        identifier: { name: wid, deviceId: 0 },
-        identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
-    };
+//=======================================================//
+import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from "../WABinary/index.js";
+import { Curve, generateSignalPubKey } from "./crypto.js";
+import { KEY_BUNDLE_TYPE } from "../Defaults/index.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)
+  };
 };
-exports.createSignalIdentity = createSignalIdentity;
-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);
 };
-exports.getPreKeys = getPreKeys;
-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] = crypto_1.Curve.generateKeyPair();
-        }
+//=======================================================//
+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,
-        lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range],
-    };
+  }
+  return {
+    newPreKeys,
+    lastPreKeyId,
+    preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+  };
 };
-exports.generateOrGetPreKeys = generateOrGetPreKeys;
-const xmppSignedPreKey = (key) => ({
-    tag: 'skey',
-    attrs: {},
-    content: [
-        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
-        { tag: 'value', attrs: {}, content: key.keyPair.public },
-        { tag: 'signature', attrs: {}, content: key.signature }
-    ]
+//=======================================================//
+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 }
+  ]
 });
-exports.xmppSignedPreKey = xmppSignedPreKey;
-const xmppPreKey = (pair, id) => ({
-    tag: 'key',
-    attrs: {},
-    content: [
-        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
-        { tag: 'value', attrs: {}, content: pair.public }
-    ]
+//=======================================================//
+export const xmppPreKey = (pair, id) => ({
+  tag: "key",
+  attrs: {},
+  content: [
+    { tag: "id", attrs: {}, content: encodeBigEndian(id, 3) },
+    { tag: "value", attrs: {}, content: pair.public }
+  ]
 });
-exports.xmppPreKey = xmppPreKey;
-const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = (key) => (key ? ({
-        keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
-        publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
-        signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature'),
-    }) : undefined);
-    const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user');
-    for (const node of nodes) {
-        (0, WABinary_1.assertNodeErrorFree)(node);
+//=======================================================//
+export const parseAndInjectE2ESessions = async (node, repository) => {
+  const extractKey = (key) => key
+    ? {
+      keyId: getBinaryNodeChildUInt(key, "id", 3),
+      publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, "value")),
+      signature: getBinaryNodeChildBuffer(key, "signature")
     }
-    await Promise.all(nodes.map(async (node) => {
-        const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
-        const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
-        const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
-        const jid = node.attrs.jid;
-        const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
-        await repository.injectE2ESession({
-            jid,
-            session: {
-                registrationId: registrationId,
-                identityKey: (0, crypto_1.generateSignalPubKey)(identity),
-                signedPreKey: extractKey(signedKey),
-                preKey: extractKey(key)
-            }
-        });
-    }));
+    : 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)
+        }
+      });
+    }
+  }
 };
-exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
-const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    var _a;
-    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
-    const extracted = [];
-    for (const node of result.content) {
-        const list = (_a = (0, WABinary_1.getBinaryNodeChild)(node, 'list')) === null || _a === void 0 ? void 0 : _a.content;
-        if (list && Array.isArray(list)) {
-            for (const item of list) {
-                const { user } = (0, WABinary_1.jidDecode)(item.attrs.jid);
-                const devicesNode = (0, WABinary_1.getBinaryNodeChild)(item, 'devices');
-                const deviceListNode = (0, WABinary_1.getBinaryNodeChild)(devicesNode, 'device-list');
-                if (Array.isArray(deviceListNode === null || deviceListNode === void 0 ? void 0 : deviceListNode.content)) {
-                    for (const { tag, attrs } of deviceListNode.content) {
-                        const device = +attrs.id;
-                        if (tag === 'device' && // ensure the "device" tag
-                            (!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
-                            (myUser !== user || myDevice !== device) && // either different user or if me user, not this device
-                            (device === 0 || !!attrs['key-index']) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-                        ) {
-                            extracted.push({ user, device });
-                        }
-                    }
-                }
-            }
+//=======================================================//
+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) &&
+        ((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;
 };
-exports.extractDeviceJids = extractDeviceJids;
-/**
- * get the next N keys for upload or processing
- * @param count number of pre-keys to get or generate
- */
-const getNextPreKeys = async ({ creds, keys }, count) => {
-    const { newPreKeys, lastPreKeyId, preKeysRange } = (0, exports.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 (0, exports.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 };
 };
-exports.getNextPreKeys = getNextPreKeys;
-const getNextPreKeysNode = async (state, count) => {
-    const { creds } = state;
-    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
-    const node = {
-        tag: 'iq',
-        attrs: {
-            xmlns: 'encrypt',
-            type: 'set',
-            to: WABinary_1.S_WHATSAPP_NET,
-        },
-        content: [
-            { tag: 'registration', attrs: {}, content: (0, generics_1.encodeBigEndian)(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
-            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
-            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
-            (0, exports.xmppSignedPreKey)(creds.signedPreKey)
-        ]
-    };
-    return { update, node };
+//=======================================================//
+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 };
 };
-exports.getNextPreKeysNode = getNextPreKeysNode;
+//=======================================================//

package/lib/Utils/use-multi-file-auth-state.js

@@ -1,80 +1,111 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useMultiFileAuthState = void 0;
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const WAProto_1 = require("../../WAProto");
-const auth_utils_1 = require("./auth-utils");
-const generics_1 = require("./generics");
-/**
- * stores the full authentication state in a single folder.
- * Far more efficient than singlefileauthstate
- *
- * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
- * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
- * */
-const useMultiFileAuthState = async (folder) => {
-    const writeData = (data, file) => {
-        return (0, promises_1.writeFile)((0, path_1.join)(folder, fixFileName(file)), JSON.stringify(data, generics_1.BufferJSON.replacer));
-    };
-    const readData = async (file) => {
+//=======================================================//
+import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import { initAuthCreds } from "./auth-utils.js";
+import { proto } from "../../WAProto/index.js";
+import { BufferJSON } from "./generics.js";
+import { Mutex } from "async-mutex";
+import { join } from "path";
+//=======================================================//
+const fileLocks = new Map();
+const getFileLock = (path) => {
+  let mutex = fileLocks.get(path);
+  if (!mutex) {
+    mutex = new Mutex();
+    fileLocks.set(path, mutex);
+  }
+  return mutex;
+};
+//=======================================================//
+export const useMultiFileAuthState = async (folder) => {
+  const writeData = async (data, file) => {
+    const filePath = join(folder, fixFileName(file));
+    const mutex = getFileLock(filePath);
+    return mutex.acquire().then(async (release) => {
+      try {
+        await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
+      }
+      finally {
+        release();
+      }
+    });
+  };
+  const readData = async (file) => {
+    try {
+      const filePath = join(folder, fixFileName(file));
+      const mutex = getFileLock(filePath);
+      return await mutex.acquire().then(async (release) => {
         try {
-            const data = await (0, promises_1.readFile)((0, path_1.join)(folder, fixFileName(file)), { encoding: 'utf-8' });
-            return JSON.parse(data, generics_1.BufferJSON.reviver);
+          const data = await readFile(filePath, { encoding: "utf-8" });
+          return JSON.parse(data, BufferJSON.reviver);
         }
-        catch (error) {
-            return null;
+        finally {
+          release();
         }
-    };
-    const removeData = async (file) => {
+      });
+    }
+    catch (error) {
+      return null;
+    }
+  };
+  const removeData = async (file) => {
+    try {
+      const filePath = join(folder, fixFileName(file));
+      const mutex = getFileLock(filePath);
+      return mutex.acquire().then(async (release) => {
         try {
-            await (0, promises_1.unlink)((0, path_1.join)(folder, fixFileName(file)));
+          await unlink(filePath);
         }
-        catch (_a) {
+        catch {
         }
-    };
-    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
-    if (folderInfo) {
-        if (!folderInfo.isDirectory()) {
-            throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
+        finally {
+          release();
         }
+      });
     }
-    else {
-        await (0, promises_1.mkdir)(folder, { recursive: true });
+    catch { }
+  };
+  const folderInfo = await stat(folder).catch(() => { });
+  if (folderInfo) {
+    if (!folderInfo.isDirectory()) {
+      throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
     }
-    const fixFileName = (file) => { var _a; return (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.replace(/:/g, '-'); };
-    const creds = await readData('creds.json') || (0, auth_utils_1.initAuthCreds)();
-    return {
-        state: {
-            creds,
-            keys: {
-                get: async (type, ids) => {
-                    const data = {};
-                    await Promise.all(ids.map(async (id) => {
-                        let value = await readData(`${type}-${id}.json`);
-                        if (type === 'app-state-sync-key' && value) {
-                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
-                        }
-                        data[id] = value;
-                    }));
-                    return data;
-                },
-                set: async (data) => {
-                    const tasks = [];
-                    for (const category in data) {
-                        for (const id in data[category]) {
-                            const value = data[category][id];
-                            const file = `${category}-${id}.json`;
-                            tasks.push(value ? writeData(value, file) : removeData(file));
-                        }
-                    }
-                    await Promise.all(tasks);
-                }
+  }
+  else {
+    await mkdir(folder, { recursive: true });
+  }
+  const fixFileName = (file) => file?.replace(/\//g, "__")?.replace(/:/g, "-");
+  const creds = (await readData("creds.json")) || initAuthCreds();
+  return {
+    state: {
+      creds,
+      keys: {
+        get: async (type, ids) => {
+          const data = {};
+          await Promise.all(ids.map(async (id) => {
+            let value = await readData(`${type}-${id}.json`);
+            if (type === "app-state-sync-key" && value) {
+              value = proto.Message.AppStateSyncKeyData.fromObject(value);
             }
+            data[id] = value;
+          }));
+          return data;
         },
-        saveCreds: () => {
-            return writeData(creds, 'creds.json');
+        set: async (data) => {
+          const tasks = [];
+          for (const category in data) {
+            for (const id in data[category]) {
+              const value = data[category][id];
+              const file = `${category}-${id}.json`;
+              tasks.push(value ? writeData(value, file) : removeData(file));
+            }
+          }
+          await Promise.all(tasks);
         }
-    };
+      }
+    },
+    saveCreds: async () => {
+      return writeData(creds, "creds.json");
+    }
+  };
 };
-exports.useMultiFileAuthState = useMultiFileAuthState;
+//=======================================================//