@neelegirl/baileys 1.5.6 → 1.5.7

package/lib/Utils/signal.d.ts

@@ -1,34 +1,42 @@
-import type { SignalRepositoryWithLIDStore } from '../Types/index.js';
-import type { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth.js';
-import { type BinaryNode, type FullJid } from '../WABinary/index.js';
-import type { USyncQueryResultList } from '../WAUSync/index.js';
-export declare const createSignalIdentity: (wid: string, accountSignatureKey: Uint8Array) => SignalIdentity;
+import { SignalRepository } from '../Types'
+import { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth'
+import { BinaryNode, JidWithDevice } from '../WABinary'
+import { USyncQueryResultList } from '../WAUSync'
+
+export declare const createSignalIdentity: (wid: string, accountSignatureKey: Uint8Array) => SignalIdentity
+
 export declare const getPreKeys: ({ get }: SignalKeyStore, min: number, limit: number) => Promise<{
-    [id: string]: KeyPair;
-}>;
+    [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: SignalRepositoryWithLIDStore) => Promise<void>;
-export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, myLid: string, excludeZeroDevices: boolean) => FullJid[];
+        [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: USyncQueryResultList[], 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>;
+    update: Partial<AuthenticationCreds>
     preKeys: {
-        [id: string]: KeyPair;
-    };
-}>;
+        [id: string]: KeyPair
+    }
+}>
+
 export declare const getNextPreKeysNode: (state: AuthenticationState, count: number) => Promise<{
-    update: Partial<AuthenticationCreds>;
-    node: BinaryNode;
-}>;
-//# sourceMappingURL=signal.d.ts.map
+    update: Partial<AuthenticationCreds>
+    node: BinaryNode
+}>

package/lib/Utils/signal.js

@@ -1,159 +1,166 @@
-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) => {
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const lodash_1 = require("lodash")
+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: generateSignalPubKey(accountSignatureKey)
-    };
-};
-export const getPreKeys = async ({ get }, min, limit) => {
-    const idList = [];
+        identifierKey: crypto_1.generateSignalPubKey(accountSignatureKey)
+    }
+}
+
+const getPreKeys = async ({ get }, min, limit) => {
+    const idList = []
     for (let id = min; id < limit; id++) {
-        idList.push(id.toString());
+        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 = {};
+    return get('pre-key', idList)
+}
+
+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();
+            newPreKeys[i] = crypto_1.Curve.generateKeyPair()
         }
     }
     return {
         newPreKeys,
         lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
-    };
-};
-export const xmppSignedPreKey = (key) => ({
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range],
+    }
+}
+
+const xmppSignedPreKey = (key) => ({
     tag: 'skey',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+        { tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(key.keyId, 3) },
         { tag: 'value', attrs: {}, content: key.keyPair.public },
         { tag: 'signature', attrs: {}, content: key.signature }
     ]
-});
-export const xmppPreKey = (pair, id) => ({
+})
+
+const xmppPreKey = (pair, id) => ({
     tag: 'key',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: 'id', attrs: {}, content: 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')
-        }
-        : undefined;
-    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user');
+})
+
+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) {
-        assertNodeErrorFree(node);
+        WABinary_1.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);
+    const chunkSize = 100
+    const chunks = lodash_1.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 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: generateSignalPubKey(identity),
+                    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 = [];
+}
+
+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 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;
+        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;
-};
+    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 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);
+    }
+    await keys.set({ 'pre-key': newPreKeys })
+    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
+    return { update, preKeys }
+}
+
+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
+            to: WABinary_1.S_WHATSAPP_NET,
         },
         content: [
-            { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
+            { tag: 'registration', attrs: {}, content: 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 => xmppPreKey(preKeys[+k], +k)) },
             xmppSignedPreKey(creds.signedPreKey)
         ]
-    };
-    return { update, node };
-};
-//# sourceMappingURL=signal.js.map
+    }
+    return { update, node }
+}
+
+module.exports = {
+  createSignalIdentity, 
+  getPreKeys, 
+  generateOrGetPreKeys, 
+  xmppSignedPreKey, 
+  xmppPreKey, 
+  parseAndInjectE2ESessions, 
+  extractDeviceJids, 
+  getNextPreKeys, 
+  getNextPreKeysNode
+}

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

@@ -0,0 +1,6 @@
+import { AuthenticationState } from '../Types'
+
+export declare const useMongoFileAuthState: (collection: string) => Promise<{
+    state: AuthenticationState
+    saveCreds: () => Promise<void>
+}>

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

@@ -0,0 +1,84 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const WAProto_1 = require("../../WAProto")
+const auth_utils_1 = require("./auth-utils")
+const generics_1 = require("./generics")
+
+/*
+code from amiruldev readjusted by @irull2nd, don't delete WM!
+*/
+const useMongoFileAuthState = async (collection) => {
+  const writeData = (data,id) => {
+    const informationToStore = JSON.parse(
+      JSON.stringify(data, generics_1.BufferJSON.replacer)
+    )
+    const update = {
+      $set: {
+        ...informationToStore,
+      },
+    }
+
+    return collection.updateOne({_id: id},update, {upsert: true})
+  }
+
+  const readData = async (id) => {
+    try {
+      const data = JSON.stringify(await collection.findOne({_id: id}))
+      return JSON.parse(data, generics_1.BufferJSON.reviver)
+    } catch (err) {
+      console.log(err)
+    }
+  }
+
+  const removeData = async (id) => {
+    try{
+      await collection.deleteOne({_id: id})
+    }catch(err){
+      console.log('error',err)
+    }
+  }
+
+  const creds = (await readData('creds')) || 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}`)
+              if(type === "app-state-sync-key"){
+                value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(data)
+              }
+              data[id] = value
+            })
+          )
+          return data
+        },
+        set: async (data) => {
+          const tasks = []
+          for (const category of Object.keys(data)){
+            for (const id of Object.keys(data[category])){
+              const value = data[category][id]
+              const key = `${category}-${id}`
+              tasks.push(value? writeData(value,key) : removeData(key))
+            }
+          }
+          await Promise.all(tasks)
+        },
+      },
+    },
+    saveCreds: () => {
+      return writeData(creds, "creds")
+    }
+  }
+}
+
+module.exports = {
+  useMongoFileAuthState
+}

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

@@ -1,4 +1,5 @@
-import type { AuthenticationState } from '../Types/index.js';
+import { AuthenticationState } from '../Types'
+
 /**
  * stores the full authentication state in a single folder.
  * Far more efficient than singlefileauthstate
@@ -7,7 +8,11 @@ import type { AuthenticationState } from '../Types/index.js';
  * 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>;
-}>;
-//# sourceMappingURL=use-multi-file-auth-state.d.ts.map
+    state: AuthenticationState
+    saveCreds: () => Promise<void>
+}>
+
+export declare const useMultiFileAuthStateV2: (folder: string) => Promise<{
+    state: AuthenticationState
+    saveCreds: () => Promise<void>
+}>