@skyzopedia/baileys-mod 5.0.8 → 6.0.1

package/lib/Utils/signal.d.ts

@@ -0,0 +1,32 @@
+import { SignalRepository } from '../Types';
+import { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth';
+import { BinaryNode, JidWithDevice } from '../WABinary';
+export declare const createSignalIdentity: (wid: string, accountSignatureKey: Uint8Array) => SignalIdentity;
+export declare const getPreKeys: ({ get }: SignalKeyStore, min: number, limit: number) => Promise<{
+    [id: string]: KeyPair;
+}>;
+export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: number) => {
+    newPreKeys: {
+        [id: number]: KeyPair;
+    };
+    lastPreKeyId: number;
+    preKeysRange: readonly [number, number];
+};
+export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode;
+export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode;
+export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepository) => Promise<void>;
+export declare const extractDeviceJids: (result: BinaryNode, myJid: string, excludeZeroDevices: boolean) => JidWithDevice[];
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+export declare const getNextPreKeys: ({ creds, keys }: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>;
+    preKeys: {
+        [id: string]: KeyPair;
+    };
+}>;
+export declare const getNextPreKeysNode: (state: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>;
+    node: BinaryNode;
+}>;

package/lib/Utils/signal.js

@@ -1,161 +1,153 @@
-//=======================================================//
-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)
-  };
+"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 lodash_1 = require("lodash")
+const generics_1 = require("./generics");
+const createSignalIdentity = (wid, accountSignatureKey) => {
+    return {
+        identifier: { name: wid, deviceId: 0 },
+        identifierKey: (0, crypto_1.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);
+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 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();
+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();
+        }
     }
-  }
-  return {
-    newPreKeys,
-    lastPreKeyId,
-    preKeysRange: [creds.firstUnuploadedPreKeyId, range]
-  };
+    return {
+        newPreKeys,
+        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 }
-  ]
+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 xmppPreKey = (pair, id) => ({
-  tag: "key",
-  attrs: {},
-  content: [
-    { tag: "id", attrs: {}, content: encodeBigEndian(id, 3) },
-    { tag: "value", attrs: {}, content: pair.public }
-  ]
+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 parseAndInjectE2ESessions = async (node, repository) => {
-  const extractKey = (key) => key
-    ? {
-      keyId: getBinaryNodeChildUInt(key, "id", 3),
-      publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, "value")),
-      signature: getBinaryNodeChildBuffer(key, "signature")
+exports.xmppPreKey = xmppPreKey;
+const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => (key ? ({
+        keyId: WABinary_1.getBinaryNodeChildUInt(key, 'id', 3),
+        publicKey: crypto_1.generateSignalPubKey(WABinary_1.getBinaryNodeChildBuffer(key, 'value')),
+        signature: WABinary_1.getBinaryNodeChildBuffer(key, 'signature')
+    }) : undefined)
+    const nodes = WABinary_1.getBinaryNodeChildren(WABinary_1.getBinaryNodeChild(node, 'list'), 'user')
+    for (const node of nodes) {
+        WABinary_1.assertNodeErrorFree(node)
     }
-    : 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)
-        }
-      });
+    // 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 = lodash_1.chunk(nodes, chunkSize)
+    for (const nodesChunk of chunks) {
+        await Promise.all(nodesChunk.map(async (node) => {
+            const signedKey = WABinary_1.getBinaryNodeChild(node, 'skey')
+            const key = WABinary_1.getBinaryNodeChild(node, 'key')
+            const identity = WABinary_1.getBinaryNodeChildBuffer(node, 'identity')
+            const jid = node.attrs.jid
+            const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
+            await repository.injectE2ESession({
+                jid,
+                session: {
+                    registrationId: registrationId,
+                    identityKey: crypto_1.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) &&
-        ((myUser !== user && myLid !== user) || myDevice !== device) &&
-        (device === 0 || !!keyIndex)
-      ) {
-        if (isHosted) {
-          domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
+}
+exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
+const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
+    const extracted = []
+    for (const userResult of result) {
+        const { devices, id } = userResult
+        const { user } = WABinary_1.jidDecode(id)
+        const deviceList = devices?.deviceList
+        if (Array.isArray(deviceList)) {
+            for (const { id: device, keyIndex } of deviceList) {
+                if ((!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 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+                ) {
+                    extracted.push({ user, device })
+                }
+            }
         }
-        extracted.push({
-          user,
-          device,
-          domainType,
-          server: getServerFromDomainType(server, domainType)
-        });
-      }
     }
-  }
-  return extracted;
-};
-//=======================================================//
-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 };
+    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 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.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 };
 };
-//=======================================================//
+exports.getNextPreKeysNode = getNextPreKeysNode;

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticationState } from '../Types';
+/**
+ * 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
+ * */
+export declare const useMultiFileAuthState: (folder: string) => Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+}>;
+ 

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

@@ -1,111 +1,119 @@
-//=======================================================//
-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";
-//=======================================================//
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMultiFileAuthState = void 0;
+const async_mutex_1 = require("async-mutex");
+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");
 const fileLocks = new Map();
 const getFileLock = (path) => {
-  let mutex = fileLocks.get(path);
-  if (!mutex) {
-    mutex = new Mutex();
-    fileLocks.set(path, mutex);
-  }
-  return mutex;
+    let mutex = fileLocks.get(path);
+    if (!mutex) {
+        mutex = new async_mutex_1.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) => {
+/**
+ * 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 = async (data, file) => {
+        const filePath = (0, path_1.join)(folder, fixFileName(file));
+        const mutex = getFileLock(filePath);
+        return mutex.acquire().then(async (release) => {
+            try {
+                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer));
+            }
+            finally {
+                release();
+            }
+        });
+    };
+    const readData = async (file) => {
         try {
-          const data = await readFile(filePath, { encoding: "utf-8" });
-          return JSON.parse(data, BufferJSON.reviver);
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return await mutex.acquire().then(async (release) => {
+                try {
+                    const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
+                    return JSON.parse(data, generics_1.BufferJSON.reviver);
+                }
+                finally {
+                    release();
+                }
+            });
         }
-        finally {
-          release();
+        catch (error) {
+            return null;
         }
-      });
-    }
-    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) => {
+    };
+    const removeData = async (file) => {
         try {
-          await unlink(filePath);
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return mutex.acquire().then(async (release) => {
+                try {
+                    await (0, promises_1.unlink)(filePath);
+                }
+                catch (_a) {
+                }
+                finally {
+                    release();
+                }
+            });
         }
-        catch {
+        catch (_a) {
         }
-        finally {
-          release();
+    };
+    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`);
         }
-      });
     }
-    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`);
+    else {
+        await (0, promises_1.mkdir)(folder, { recursive: true });
     }
-  }
-  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);
+    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);
+                }
             }
-            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);
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
         }
-      }
-    },
-    saveCreds: async () => {
-      return writeData(creds, "creds.json");
-    }
-  };
+    };
 };
-//=======================================================//
+exports.useMultiFileAuthState = useMultiFileAuthState;

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,11 @@
+import { proto } from '../../WAProto';
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const generateMobileNode: (config: SocketConfig) => proto.IClientPayload;
+export declare const generateLoginNode: (userJid: string, config: SocketConfig) => proto.IClientPayload;
+export declare const generateRegistrationNode: ({ registrationId, signedPreKey, signedIdentityKey }: SignalCreds, config: SocketConfig) => proto.ClientPayload;
+export declare const configureSuccessfulPairing: (stanza: BinaryNode, { advSecretKey, signedIdentityKey, signalIdentities }: Pick<AuthenticationCreds, 'advSecretKey' | 'signedIdentityKey' | 'signalIdentities'>) => {
+    creds: Partial<AuthenticationCreds>;
+    reply: BinaryNode;
+}; 
+export declare const encodeSignedDeviceIdentity: (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => Uint8Array;