@d0v3riz/baileys 6.3.0 → 6.4.0

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/Defaults/baileys-version.json

@@ -1,3 +1,3 @@
 {
-    "version": [2, 2325, 3]
+    "version": [2, 2329, 9]
 }

package/lib/Defaults/index.js

@@ -49,7 +49,7 @@ exports.DEFAULT_CONNECTION_CONFIG = {
     browser: Utils_1.Browsers.baileys('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,
-    keepAliveIntervalMs: 15000,
+    keepAliveIntervalMs: 30000,
     logger: logger_1.default.child({ class: 'baileys' }),
     printQRInTerminal: false,
     emitOwnEvents: true,

package/lib/Socket/Client/abstract-socket-client.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { EventEmitter } from 'events';
 import { URL } from 'url';
 import { SocketConfig } from '../../Types';

package/lib/Socket/business.d.ts

@@ -7,7 +7,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         products: import("../Types").Product[];
         nextPageCursor: string | undefined;
     }>;
-    getCollections: (jid?: string | undefined, limit?: number) => Promise<{
+    getCollections: (jid?: string, limit?: number) => Promise<{
         collections: import("../Types").CatalogCollection[];
     }>;
     productCreate: (create: ProductCreate) => Promise<import("../Types").Product>;
@@ -20,7 +20,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     getPrivacyTokens: (jids: string[]) => Promise<BinaryNode>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
-    relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata }: import("../Types").MessageRelayOptions) => Promise<string>;
+    relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata, statusJidList }: import("../Types").MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../Types").MessageReceiptType) => Promise<void>;
     sendReceipts: (keys: import("../Types").WAProto.IMessageKey[], type: import("../Types").MessageReceiptType) => Promise<void>;
     readMessages: (keys: import("../Types").WAProto.IMessageKey[]) => Promise<void>;
@@ -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>;
@@ -95,7 +96,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     type: "md";
-    ws: import("./Client").MobileSocketClient | import("./Client").WebSocketClient;
+    ws: import("./Client/mobile-socket-client").MobileSocketClient | import("./Client/web-socket-client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -120,5 +121,6 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
 };

package/lib/Socket/chats.d.ts

@@ -12,9 +12,9 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
     }>;
     upsertMessage: (msg: proto.IWebMessageInfo, type: MessageUpsertType) => Promise<void>;
     appPatch: (patchCreate: WAPatchCreate) => Promise<void>;
-    sendPresenceUpdate: (type: WAPresence, toJid?: string | undefined) => Promise<void>;
-    presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
-    profilePictureUrl: (jid: string, type?: 'preview' | 'image', timeoutMs?: number | undefined) => Promise<string | undefined>;
+    sendPresenceUpdate: (type: WAPresence, toJid?: string) => Promise<void>;
+    presenceSubscribe: (toJid: string, tcToken?: Buffer) => Promise<void>;
+    profilePictureUrl: (jid: string, type?: 'preview' | 'image', timeoutMs?: number) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
         exists: boolean;
         jid: string;
@@ -39,13 +39,13 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
     getBusinessProfile: (jid: string) => Promise<WABusinessProfile | void>;
     resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
     chatModify: (mod: ChatModification, jid: string) => Promise<void>;
-    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: string | number | undefined) => Promise<void>;
+    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: number | string) => Promise<void>;
     addChatLabel: (jid: string, labelId: string) => Promise<void>;
     removeChatLabel: (jid: string, labelId: string) => Promise<void>;
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     type: "md";
-    ws: import("./Client").MobileSocketClient | import("./Client").WebSocketClient;
+    ws: import("./Client/mobile-socket-client").MobileSocketClient | import("./Client/web-socket-client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -70,5 +70,6 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
     onUnexpectedError: (err: Error | Boom<any>, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
 };

package/lib/Socket/groups.d.ts

@@ -17,8 +17,9 @@ 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>;
+    groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
     groupRevokeInvite: (jid: string) => Promise<string | undefined>;
     groupAcceptInvite: (code: string) => Promise<string | undefined>;
@@ -75,7 +76,7 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     type: "md";
-    ws: import("./Client").MobileSocketClient | import("./Client").WebSocketClient;
+    ws: import("./Client/mobile-socket-client").MobileSocketClient | import("./Client/web-socket-client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -100,6 +101,7 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
 };
 export declare const extractGroupMetadata: (result: BinaryNode) => GroupMetadata;

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

@@ -16,12 +16,12 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
         deleted: number;
     }>;
     productUpdate: (productId: string, update: import("../Types").ProductUpdate) => Promise<import("../Types").Product>;
-    sendMessageAck: ({ tag, attrs }: import("..").BinaryNode) => Promise<void>;
-    sendRetryRequest: (node: import("..").BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
+    sendMessageAck: ({ tag, attrs }: import("../index").BinaryNode) => Promise<void>;
+    sendRetryRequest: (node: import("../index").BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
-    getPrivacyTokens: (jids: string[]) => Promise<import("..").BinaryNode>;
+    getPrivacyTokens: (jids: string[]) => Promise<import("../index").BinaryNode>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
-    relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata }: import("../Types").MessageRelayOptions) => Promise<string>;
+    relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata, statusJidList }: import("../Types").MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../Types").MessageReceiptType) => Promise<void>;
     sendReceipts: (keys: import("../Types").WAProto.IMessageKey[], type: import("../Types").MessageReceiptType) => Promise<void>;
     readMessages: (keys: import("../Types").WAProto.IMessageKey[]) => Promise<void>;
@@ -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("../index").BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
@@ -96,7 +97,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     type: "md";
-    ws: import("./Client").MobileSocketClient | import("./Client").WebSocketClient;
+    ws: import("./Client/mobile-socket-client").MobileSocketClient | import("./Client/web-socket-client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -111,16 +112,17 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     signalRepository: import("../Types").SignalRepository;
     user: import("../Types").Contact | undefined;
     generateMessageTag: () => string;
-    query: (node: import("..").BinaryNode, timeoutMs?: number | undefined) => Promise<import("..").BinaryNode>;
+    query: (node: import("../index").BinaryNode, timeoutMs?: number | undefined) => Promise<import("../index").BinaryNode>;
     waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>;
     waitForSocketOpen: () => Promise<void>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
-    sendNode: (frame: import("..").BinaryNode) => Promise<void>;
+    sendNode: (frame: import("../index").BinaryNode) => Promise<void>;
     logout: (msg?: string | undefined) => Promise<void>;
     end: (error: Error | undefined) => void;
     onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
 };
 export default makeWASocket;

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto';
 import { MessageReceiptType, MessageRelayOptions, SocketConfig } from '../Types';
 import { BinaryNode } from '../WABinary';
@@ -8,7 +9,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     getPrivacyTokens: (jids: string[]) => Promise<BinaryNode>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
-    relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata }: MessageRelayOptions) => Promise<string>;
+    relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata, statusJidList }: MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: MessageReceiptType) => Promise<void>;
     sendReceipts: (keys: proto.IMessageKey[], type: MessageReceiptType) => Promise<void>;
     readMessages: (keys: proto.IMessageKey[]) => Promise<void>;
@@ -33,6 +34,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>;
@@ -83,7 +85,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     type: "md";
-    ws: import("./Client").MobileSocketClient | import("./Client").WebSocketClient;
+    ws: import("./Client/mobile-socket-client").MobileSocketClient | import("./Client/web-socket-client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -105,8 +107,9 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     sendNode: (frame: BinaryNode) => Promise<void>;
     logout: (msg?: string | undefined) => Promise<void>;
     end: (error: Error | undefined) => void;
-    onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
+    onUnexpectedError: (err: Error | Boom<any>, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
 };

package/lib/Socket/messages-recv.js

@@ -4,13 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeMessagesRecvSocket = void 0;
+const boom_1 = require("@hapi/boom");
+const crypto_1 = require("crypto");
 const node_cache_1 = __importDefault(require("node-cache"));
 const WAProto_1 = require("../../WAProto");
 const Defaults_1 = require("../Defaults");
 const Types_1 = require("../Types");
 const Utils_1 = require("../Utils");
+const Utils_2 = require("../Utils");
 const make_mutex_1 = require("../Utils/make-mutex");
-const process_message_1 = require("../Utils/process-message");
 const WABinary_1 = require("../WABinary");
 const groups_1 = require("./groups");
 const messages_send_1 = require("./messages-send");
@@ -169,7 +171,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':
@@ -296,11 +301,82 @@ const makeMessagesRecvSocket = (config) => {
                     });
                 }
                 break;
+            case 'link_code_companion_reg':
+                const linkCodeCompanionReg = (0, WABinary_1.getBinaryNodeChild)(node, 'link_code_companion_reg');
+                const ref = toRequiredBuffer((0, WABinary_1.getBinaryNodeChildBuffer)(linkCodeCompanionReg, 'link_code_pairing_ref'));
+                const primaryIdentityPublicKey = toRequiredBuffer((0, WABinary_1.getBinaryNodeChildBuffer)(linkCodeCompanionReg, 'primary_identity_pub'));
+                const primaryEphemeralPublicKeyWrapped = toRequiredBuffer((0, WABinary_1.getBinaryNodeChildBuffer)(linkCodeCompanionReg, 'link_code_pairing_wrapped_primary_ephemeral_pub'));
+                const codePairingPublicKey = decipherLinkPublicKey(primaryEphemeralPublicKeyWrapped);
+                const companionSharedKey = Utils_1.Curve.sharedKey(authState.creds.pairingEphemeralKeyPair.private, codePairingPublicKey);
+                const random = (0, crypto_1.randomBytes)(32);
+                const linkCodeSalt = (0, crypto_1.randomBytes)(32);
+                const linkCodePairingExpanded = (0, Utils_1.hkdf)(companionSharedKey, 32, {
+                    salt: linkCodeSalt,
+                    info: 'link_code_pairing_key_bundle_encryption_key'
+                });
+                const encryptPayload = Buffer.concat([Buffer.from(authState.creds.signedIdentityKey.public), primaryIdentityPublicKey, random]);
+                const encryptIv = (0, crypto_1.randomBytes)(12);
+                const encrypted = (0, Utils_1.aesEncryptGCM)(encryptPayload, linkCodePairingExpanded, encryptIv, Buffer.alloc(0));
+                const encryptedPayload = Buffer.concat([linkCodeSalt, encryptIv, encrypted]);
+                const identitySharedKey = Utils_1.Curve.sharedKey(authState.creds.signedIdentityKey.private, primaryIdentityPublicKey);
+                const identityPayload = Buffer.concat([companionSharedKey, identitySharedKey, random]);
+                authState.creds.advSecretKey = (0, Utils_1.hkdf)(identityPayload, 32, { info: 'adv_secret' }).toString('base64');
+                await query({
+                    tag: 'iq',
+                    attrs: {
+                        to: WABinary_1.S_WHATSAPP_NET,
+                        type: 'set',
+                        id: sock.generateMessageTag(),
+                        xmlns: 'md'
+                    },
+                    content: [
+                        {
+                            tag: 'link_code_companion_reg',
+                            attrs: {
+                                jid: authState.creds.me.id,
+                                stage: 'companion_finish',
+                            },
+                            content: [
+                                {
+                                    tag: 'link_code_pairing_wrapped_key_bundle',
+                                    attrs: {},
+                                    content: encryptedPayload
+                                },
+                                {
+                                    tag: 'companion_identity_public',
+                                    attrs: {},
+                                    content: authState.creds.signedIdentityKey.public
+                                },
+                                {
+                                    tag: 'link_code_pairing_ref',
+                                    attrs: {},
+                                    content: ref
+                                }
+                            ]
+                        }
+                    ]
+                });
+                authState.creds.registered = true;
+                ev.emit('creds.update', authState.creds);
         }
         if (Object.keys(result).length) {
             return result;
         }
     };
+    function decipherLinkPublicKey(data) {
+        const buffer = toRequiredBuffer(data);
+        const salt = buffer.slice(0, 32);
+        const secretKey = (0, Utils_1.derivePairingCodeKey)(authState.creds.pairingCode, salt);
+        const iv = buffer.slice(32, 48);
+        const payload = buffer.slice(48, 80);
+        return (0, Utils_1.aesDecryptCTR)(payload, secretKey, iv);
+    }
+    function toRequiredBuffer(data) {
+        if (data === undefined) {
+            throw new boom_1.Boom('Invalid buffer', { statusCode: 400 });
+        }
+        return data instanceof Buffer ? data : Buffer.from(data);
+    }
     const willSendMessageAgain = (id, participant) => {
         const key = `${id}:${participant}`;
         const retryCount = msgRetryCache.get(key) || 0;
@@ -501,7 +577,7 @@ const makeMessagesRecvSocket = (config) => {
                         await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
                     }
                 }
-                (0, process_message_1.cleanMessage)(msg, authState.creds.me.id);
+                (0, Utils_2.cleanMessage)(msg, authState.creds.me.id);
                 await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
             }),
             sendMessageAck(node)

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

@@ -6,7 +6,7 @@ import { BinaryNode } from '../WABinary';
 export declare const makeMessagesSocket: (config: SocketConfig) => {
     getPrivacyTokens: (jids: string[]) => Promise<BinaryNode>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
-    relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata }: MessageRelayOptions) => Promise<string>;
+    relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata, statusJidList }: MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: MessageReceiptType) => Promise<void>;
     sendReceipts: (keys: WAMessageKey[], type: MessageReceiptType) => Promise<void>;
     readMessages: (keys: WAMessageKey[]) => Promise<void>;
@@ -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>;
@@ -81,7 +82,7 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     type: "md";
-    ws: import("./Client").MobileSocketClient | import("./Client").WebSocketClient;
+    ws: import("./Client/mobile-socket-client").MobileSocketClient | import("./Client/web-socket-client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -106,5 +107,6 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     onUnexpectedError: (err: Error | Boom<any>, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
 };