@d0v3riz/baileys 6.3.0 → 6.3.1

package/README.md

@@ -1,5 +1,11 @@
 # Baileys - Typescript/Javascript WhatsApp Web API
 
+### Important Note
+
+This library was originally a project for **CS-2362 at Ashoka University** and is in no way affiliated with or endorsed by WhatsApp. Use at your own discretion. Do not spam people with this.
+We hold no liability for your use of this tool, in fact, depending on how you use this library, you'll be in violation of WhatsApp's Terms of Service. We discourage any stalkerware, bulk or automated messaging usage. 
+
+
 Baileys does not require Selenium or any other browser to be interface with WhatsApp Web, it does so directly using a **WebSocket**. 
 Not running Selenium or Chromimum saves you like **half a gig** of ram :/ 
 Baileys supports interacting with the multi-device & web versions of WhatsApp.
@@ -948,9 +954,4 @@ Some examples:
     // for any message with tag 'edge_routing', id attribute = abcd & first content node routing_info
     sock.ws.on(`CB:edge_routing,id:abcd,routing_info`, (node: BinaryNode) => { })
     ```
-
-### Note
-
- This library was originally a project for **CS-2362 at Ashoka University** and is in no way affiliated with WhatsApp. Use at your own discretion. Do not spam people with this.
-
  Also, this repo is now licenced under GPL 3 since it uses [libsignal-node](https://git.questbook.io/backend/service-coderunner/-/merge_requests/1)

package/WASignalGroup/group_cipher.js

@@ -1,3 +1,4 @@
+const queue_job = require('./queue_job');
 const SenderKeyMessage = require('./sender_key_message');
 const crypto = require('libsignal/src/crypto');
 
@@ -7,11 +8,22 @@ class GroupCipher {
     this.senderKeyName = senderKeyName;
   }
 
+  queueJob(awaitable) {
+    return queue_job(this.senderKeyName.toString(), awaitable)
+  }
+
   async encrypt(paddedPlaintext) {
-    try {
+    return await this.queueJob(async () => {
       const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+      if (!record) {
+        throw new Error("No SenderKeyRecord found for encryption")
+      }
       const senderKeyState = record.getSenderKeyState();
-      const senderKey = senderKeyState.getSenderChainKey().getSenderMessageKey();
+      if (!senderKeyState) {
+        throw new Error("No session to encrypt message");
+      }
+      const iteration = senderKeyState.getSenderChainKey().getIteration()
+      const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1)
 
       const ciphertext = await this.getCipherText(
         senderKey.getIv(),
@@ -25,35 +37,37 @@ class GroupCipher {
         ciphertext,
         senderKeyState.getSigningKeyPrivate()
       );
-      senderKeyState.setSenderChainKey(senderKeyState.getSenderChainKey().getNext());
       await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
-      return senderKeyMessage.serialize();
-    } catch (e) {
-      //console.log(e.stack);
-      throw new Error('NoSessionException');
-    }
+      return senderKeyMessage.serialize()
+    })
   }
 
   async decrypt(senderKeyMessageBytes) {
-    const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
-    if (!record) throw new Error(`No sender key for: ${this.senderKeyName}`);
-
-    const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+    return await this.queueJob(async () => {
+      const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+      if (!record) {
+        throw new Error("No SenderKeyRecord found for decryption")
+      }
+      const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+      const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+      if (!senderKeyState) {
+        throw new Error("No session found to decrypt message")
+      }
 
-    const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
-    senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
-    const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
-    // senderKeyState.senderKeyStateStructure.senderSigningKey.private =
+      senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+      const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+      // senderKeyState.senderKeyStateStructure.senderSigningKey.private =
 
-    const plaintext = await this.getPlainText(
-      senderKey.getIv(),
-      senderKey.getCipherKey(),
-      senderKeyMessage.getCipherText()
-    );
+      const plaintext = await this.getPlainText(
+        senderKey.getIv(),
+        senderKey.getCipherKey(),
+        senderKeyMessage.getCipherText()
+      );
 
-    await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+      await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
 
-    return plaintext;
+      return plaintext;
+    })
   }
 
   getSenderKey(senderKeyState, iteration) {
@@ -67,7 +81,7 @@ class GroupCipher {
       );
     }
 
-    if (senderChainKey.getIteration() - iteration > 2000) {
+    if (iteration - senderChainKey.getIteration() > 2000) {
       throw new Error('Over 2000 messages into the future!');
     }
 

package/WASignalGroup/queue_job.js

@@ -0,0 +1,69 @@
+// vim: ts=4:sw=4:expandtab
+
+/*
+ * jobQueue manages multiple queues indexed by device to serialize
+ * session io ops on the database.
+ */
+'use strict';
+
+
+const _queueAsyncBuckets = new Map();
+const _gcLimit = 10000;
+
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0;
+    while (true) {
+        let limit = Math.min(queue.length, _gcLimit); // Break up thundering hurds for GC duty.
+        for (let i = offt; i < limit; i++) {
+            const job = queue[i];
+            try {
+                job.resolve(await job.awaitable());
+            } catch (e) {
+                job.reject(e);
+            }
+        }
+        if (limit < queue.length) {
+            /* Perform lazy GC of queue for faster iteration. */
+            if (limit >= _gcLimit) {
+                queue.splice(0, limit);
+                offt = 0;
+            } else {
+                offt = limit;
+            }
+        } else {
+            break;
+        }
+    }
+    cleanup();
+}
+
+module.exports = function (bucket, awaitable) {
+    /* Run the async awaitable only when all other async calls registered
+     * here have completed (or thrown).  The bucket argument is a hashable
+     * key representing the task queue to use. */
+    if (!awaitable.name) {
+        // Make debuging easier by adding a name to this function.
+        Object.defineProperty(awaitable, 'name', { writable: true });
+        if (typeof bucket === 'string') {
+            awaitable.name = bucket;
+        } else {
+            console.warn("Unhandled bucket type (for naming):", typeof bucket, bucket);
+        }
+    }
+    let inactive;
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, []);
+        inactive = true;
+    }
+    const queue = _queueAsyncBuckets.get(bucket);
+    const job = new Promise((resolve, reject) => queue.push({
+        awaitable,
+        resolve,
+        reject
+    }));
+    if (inactive) {
+        /* An executor is not currently active; Start one now. */
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+    }
+    return job;
+};

package/WASignalGroup/sender_key_record.js

@@ -22,18 +22,20 @@ class SenderKeyRecord {
     }
   
     getSenderKeyState(keyId) {
-      if (!keyId && this.senderKeyStates.length) return this.senderKeyStates[0];
+      if (!keyId && this.senderKeyStates.length) return this.senderKeyStates[this.senderKeyStates.length - 1];
       for (let i = 0; i < this.senderKeyStates.length; i++) {
         const state = this.senderKeyStates[i];
         if (state.getKeyId() === keyId) {
           return state;
         }
       }
-      throw new Error(`No keys for: ${keyId}`);
     }
   
     addSenderKeyState(id, iteration, chainKey, signatureKey) {
       this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, null, signatureKey));
+      if (this.senderKeyStates.length > 5) {
+        this.senderKeyStates.shift()
+      }
     }
   
     setSenderKeyState(id, iteration, chainKey, keyPair) {

package/lib/Socket/business.d.ts

@@ -45,6 +45,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
         status: string;
         jid: string;
+        content: BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;

package/lib/Socket/groups.d.ts

@@ -17,6 +17,7 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     groupParticipantsUpdate: (jid: string, participants: string[], action: ParticipantAction) => Promise<{
         status: string;
         jid: string;
+        content: BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;

package/lib/Socket/groups.js

@@ -152,7 +152,7 @@ const makeGroupsSocket = (config) => {
             const node = (0, WABinary_1.getBinaryNodeChild)(result, action);
             const participantsAffected = (0, WABinary_1.getBinaryNodeChildren)(node, 'participant');
             return participantsAffected.map(p => {
-                return { status: p.attrs.error || '200', jid: p.attrs.jid };
+                return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p };
             });
         },
         groupUpdateDescription: async (jid, description) => {

package/lib/Socket/index.d.ts

@@ -46,6 +46,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
         status: string;
         jid: string;
+        content: import("..").BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;

package/lib/Socket/messages-recv.d.ts

@@ -33,6 +33,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
         status: string;
         jid: string;
+        content: BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;

package/lib/Socket/messages-recv.js

@@ -169,7 +169,10 @@ const makeMessagesRecvSocket = (config) => {
                         name: metadata.subject,
                         conversationTimestamp: metadata.creation,
                     }]);
-                ev.emit('groups.upsert', [metadata]);
+                ev.emit('groups.upsert', [{
+                        ...metadata,
+                        author: participant
+                    }]);
                 break;
             case 'ephemeral':
             case 'not_ephemeral':

package/lib/Socket/messages-send.d.ts

@@ -31,6 +31,7 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
         status: string;
         jid: string;
+        content: BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;

package/lib/Socket/messages-send.js

@@ -623,6 +623,7 @@ const makeMessagesSocket = (config) => {
                     ...options,
                 });
                 const isDeleteMsg = 'delete' in content && !!content.delete;
+                const isEditMsg = 'edit' in content && !!content.edit;
                 const additionalAttributes = {};
                 // required for delete
                 if (isDeleteMsg) {
@@ -634,6 +635,9 @@ const makeMessagesSocket = (config) => {
                         additionalAttributes.edit = '7';
                     }
                 }
+                else if (isEditMsg) {
+                    additionalAttributes.edit = '1';
+                }
                 await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, cachedGroupMetadata: options.cachedGroupMetadata, additionalAttributes });
                 if (config.emitOwnEvents) {
                     process.nextTick(() => {

package/lib/Socket/registration.d.ts

@@ -47,6 +47,7 @@ export declare const makeRegistrationSocket: (config: SocketConfig) => {
     groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
         status: string;
         jid: string;
+        content: import("../WABinary").BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;

package/lib/Types/GroupMetadata.d.ts

@@ -26,6 +26,8 @@ export interface GroupMetadata {
     participants: GroupParticipant[];
     ephemeralDuration?: number;
     inviteCode?: string;
+    /** the person who added you */
+    author?: string;
 }
 export interface WAGroupCreateResponse {
     status: number;

package/lib/Utils/messages.js

@@ -394,6 +394,7 @@ const generateWAMessageContent = async (message, options) => {
             protocolMessage: {
                 key: message.edit,
                 editedMessage: m,
+                timestampMs: Date.now(),
                 type: Types_1.WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT
             }
         };
@@ -431,7 +432,7 @@ const generateWAMessageFromContent = (jid, message, options) => {
         contextInfo.quotedMessage = quotedMsg;
         // if a participant is quoted, then it must be a group
         // hence, remoteJid of group must also be entered
-        if (quoted.key.participant || quoted.participant) {
+        if (jid !== quoted.key.remoteJid) {
             contextInfo.remoteJid = quoted.key.remoteJid;
         }
         message[key].contextInfo = contextInfo;
@@ -454,11 +455,6 @@ const generateWAMessageFromContent = (jid, message, options) => {
             expiration: options.ephemeralExpiration || Defaults_1.WA_DEFAULT_EPHEMERAL,
             //ephemeralSettingTimestamp: options.ephemeralOptions.eph_setting_ts?.toString()
         };
-        message = {
-            ephemeralMessage: {
-                message
-            }
-        };
     }
     message = Types_1.WAProto.Message.fromObject(message);
     const messageJSON = {

package/lib/index.d.ts

@@ -6,4 +6,5 @@ export * from './Store';
 export * from './Defaults';
 export * from './WABinary';
 export declare type WASocket = ReturnType<typeof makeWASocket>;
+export { makeWASocket };
 export default makeWASocket;

package/lib/index.js

@@ -17,7 +17,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeWASocket = void 0;
 const Socket_1 = __importDefault(require("./Socket"));
+exports.makeWASocket = Socket_1.default;
 __exportStar(require("../WAProto"), exports);
 __exportStar(require("./Utils"), exports);
 __exportStar(require("./Types"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d0v3riz/baileys",
-  "version": "6.3.0",
+  "version": "6.3.1",
   "description": "WhatsApp API",
   "keywords": [
     "whatsapp",