@genuxofficial/baileys 3.0.0 → 4.0.0

package/lib/Socket/registration.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mobileRegisterFetch = exports.mobileRegisterEncrypt = exports.mobileRegister = exports.mobileRegisterExists = exports.mobileRegisterCode = exports.registrationParams = exports.makeRegistrationSocket = void 0;
+/* eslint-disable camelcase */
+const axios_1 = __importDefault(require("axios"));
+const Defaults_1 = require("../Defaults");
+const crypto_1 = require("../Utils/crypto");
+const WABinary_1 = require("../WABinary");
+const business_1 = require("./business");
+function urlencode(str) {
+    return str.replace(/-/g, '%2d').replace(/_/g, '%5f').replace(/~/g, '%7e');
+}
+const validRegistrationOptions = (config) => (config === null || config === void 0 ? void 0 : config.phoneNumberCountryCode) &&
+    config.phoneNumberNationalNumber &&
+    config.phoneNumberMobileCountryCode;
+const makeRegistrationSocket = (config) => {
+    const sock = (0, business_1.makeBusinessSocket)(config);
+    const register = async (code) => {
+        if (!validRegistrationOptions(config.auth.creds.registration)) {
+            throw new Error('please specify the registration options');
+        }
+        const result = await mobileRegister({ ...sock.authState.creds, ...sock.authState.creds.registration, code }, config.options);
+        sock.authState.creds.me = {
+            id: (0, WABinary_1.jidEncode)(result.login, 's.whatsapp.net'),
+            name: '~'
+        };
+        sock.authState.creds.registered = true;
+        sock.ev.emit('creds.update', sock.authState.creds);
+        return result;
+    };
+    const requestRegistrationCode = async (registrationOptions) => {
+        registrationOptions = registrationOptions || config.auth.creds.registration;
+        if (!validRegistrationOptions(registrationOptions)) {
+            throw new Error('Invalid registration options');
+        }
+        sock.authState.creds.registration = registrationOptions;
+        sock.ev.emit('creds.update', sock.authState.creds);
+        return mobileRegisterCode({ ...config.auth.creds, ...registrationOptions }, config.options);
+    };
+    return {
+        ...sock,
+        register,
+        requestRegistrationCode,
+    };
+};
+exports.makeRegistrationSocket = makeRegistrationSocket;
+function convertBufferToUrlHex(buffer) {
+    var id = '';
+    buffer.forEach((x) => {
+        // encode random identity_id buffer as percentage url encoding
+        id += `%${x.toString(16).padStart(2, '0').toLowerCase()}`;
+    });
+    return id;
+}
+function registrationParams(params) {
+    const e_regid = Buffer.alloc(4);
+    e_regid.writeInt32BE(params.registrationId);
+    const e_skey_id = Buffer.alloc(3);
+    e_skey_id.writeInt16BE(params.signedPreKey.keyId);
+    params.phoneNumberCountryCode = params.phoneNumberCountryCode.replace('+', '').trim();
+    params.phoneNumberNationalNumber = params.phoneNumberNationalNumber.replace(/[/-\s)(]/g, '').trim();
+    return {
+        cc: params.phoneNumberCountryCode,
+        in: params.phoneNumberNationalNumber,
+        Rc: '0',
+        lg: 'en',
+        lc: 'GB',
+        mistyped: '6',
+        authkey: Buffer.from(params.noiseKey.public).toString('base64url'),
+        e_regid: e_regid.toString('base64url'),
+        e_keytype: 'BQ',
+        e_ident: Buffer.from(params.signedIdentityKey.public).toString('base64url'),
+        // e_skey_id: e_skey_id.toString('base64url'),
+        e_skey_id: 'AAAA',
+        e_skey_val: Buffer.from(params.signedPreKey.keyPair.public).toString('base64url'),
+        e_skey_sig: Buffer.from(params.signedPreKey.signature).toString('base64url'),
+        fdid: params.phoneId,
+        network_ratio_type: '1',
+        expid: params.deviceId,
+        simnum: '1',
+        hasinrc: '1',
+        pid: Math.floor(Math.random() * 1000).toString(),
+        id: convertBufferToUrlHex(params.identityId),
+        backup_token: convertBufferToUrlHex(params.backupToken),
+        token: (0, crypto_1.md5)(Buffer.concat([Defaults_1.MOBILE_TOKEN, Buffer.from(params.phoneNumberNationalNumber)])).toString('hex'),
+        fraud_checkpoint_code: params.captcha,
+    };
+}
+exports.registrationParams = registrationParams;
+/**
+ * Requests a registration code for the given phone number.
+ */
+function mobileRegisterCode(params, fetchOptions) {
+    return mobileRegisterFetch('/code', {
+        params: {
+            ...registrationParams(params),
+            mcc: `${params.phoneNumberMobileCountryCode}`.padStart(3, '0'),
+            mnc: `${params.phoneNumberMobileNetworkCode || '001'}`.padStart(3, '0'),
+            sim_mcc: '000',
+            sim_mnc: '000',
+            method: (params === null || params === void 0 ? void 0 : params.method) || 'sms',
+            reason: '',
+            hasav: '1'
+        },
+        ...fetchOptions,
+    });
+}
+exports.mobileRegisterCode = mobileRegisterCode;
+function mobileRegisterExists(params, fetchOptions) {
+    return mobileRegisterFetch('/exist', {
+        params: registrationParams(params),
+        ...fetchOptions
+    });
+}
+exports.mobileRegisterExists = mobileRegisterExists;
+/**
+ * Registers the phone number on whatsapp with the received OTP code.
+ */
+async function mobileRegister(params, fetchOptions) {
+    //const result = await mobileRegisterFetch(`/reg_onboard_abprop?cc=${params.phoneNumberCountryCode}&in=${params.phoneNumberNationalNumber}&rc=0`)
+    return mobileRegisterFetch('/register', {
+        params: { ...registrationParams(params), code: params.code.replace('-', '') },
+        ...fetchOptions,
+    });
+}
+exports.mobileRegister = mobileRegister;
+/**
+ * Encrypts the given string as AEAD aes-256-gcm with the public whatsapp key and a random keypair.
+ */
+function mobileRegisterEncrypt(data) {
+    const keypair = crypto_1.Curve.generateKeyPair();
+    const key = crypto_1.Curve.sharedKey(keypair.private, Defaults_1.REGISTRATION_PUBLIC_KEY);
+    const buffer = (0, crypto_1.aesEncryptGCM)(Buffer.from(data), new Uint8Array(key), Buffer.alloc(12), Buffer.alloc(0));
+    return Buffer.concat([Buffer.from(keypair.public), buffer]).toString('base64url');
+}
+exports.mobileRegisterEncrypt = mobileRegisterEncrypt;
+async function mobileRegisterFetch(path, opts = {}) {
+    let url = `${Defaults_1.MOBILE_REGISTRATION_ENDPOINT}${path}`;
+    if (opts.params) {
+        const parameter = [];
+        for (const param in opts.params) {
+            if (opts.params[param] !== null && opts.params[param] !== undefined) {
+                parameter.push(param + '=' + urlencode(opts.params[param]));
+            }
+        }
+        url += `?${parameter.join('&')}`;
+        delete opts.params;
+    }
+    if (!opts.headers) {
+        opts.headers = {};
+    }
+    opts.headers['User-Agent'] = Defaults_1.MOBILE_USERAGENT;
+    const response = await (0, axios_1.default)(url, opts);
+    var json = response.data;
+    if (response.status > 300 || json.reason) {
+        throw json;
+    }
+    if (json.status && !['ok', 'sent'].includes(json.status)) {
+        throw json;
+    }
+    return json;
+}
+exports.mobileRegisterFetch = mobileRegisterFetch;

package/lib/Socket/socket.d.ts

@@ -3,7 +3,6 @@
 import { Boom } from '@hapi/boom';
 import { SocketConfig } from '../Types';
 import { BinaryNode } from '../WABinary';
-import { WebSocketClient } from './Client';
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -12,7 +11,7 @@ import { WebSocketClient } from './Client';
  */
 export declare const makeSocket: (config: SocketConfig) => {
     type: "md";
-    ws: WebSocketClient;
+    ws: any;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -27,8 +26,8 @@ export declare const makeSocket: (config: SocketConfig) => {
     signalRepository: import("../Types").SignalRepository;
     readonly user: import("../Types").Contact | undefined;
     generateMessageTag: () => string;
-    query: (node: BinaryNode, timeoutMs?: number) => Promise<any>;
-    waitForMessage: <T_1>(msgId: string, timeoutMs?: number | undefined) => Promise<any>;
+    query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    waitForMessage: <T_1>(msgId: string, timeoutMs?: number | undefined) => Promise<T_1>;
     waitForSocketOpen: () => Promise<void>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
     sendNode: (frame: BinaryNode) => Promise<void>;
@@ -40,6 +39,6 @@ export declare const makeSocket: (config: SocketConfig) => {
     requestPairingCode: (phoneNumber: string, pairCode: string) => Promise<string>;
     /** Waits for the connection to WA to reach a state */
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number | undefined) => Promise<void>;
-    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
 };
 export type Socket = ReturnType<typeof makeSocket>;

package/lib/Socket/socket.js

@@ -20,14 +20,15 @@ const Client_1 = require("./Client");
 const makeSocket = (config) => {
     var _a, _b;
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository, } = config;
-    const url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
-    if (config.mobile || url.protocol === 'tcp:') {
-        throw new boom_1.Boom('Mobile API is not supported anymore', { statusCode: Types_1.DisconnectReason.loggedOut });
+    let url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
+    config.mobile = config.mobile || url.protocol === 'tcp:';
+    if (config.mobile && url.protocol !== 'tcp:') {
+        url = new url_1.URL(`tcp://${Defaults_1.MOBILE_ENDPOINT}:${Defaults_1.MOBILE_PORT}`);
     }
-    if (url.protocol === 'wss' && ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.routingInfo)) {
+    if (!config.mobile && url.protocol === 'wss' && ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.routingInfo)) {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
-    const ws = new Client_1.WebSocketClient(url, config);
+    const ws = config.socket ? config.socket : config.mobile ? new Client_1.MobileSocketClient(url, config) : new Client_1.WebSocketClient(url, config);
     ws.connect();
     const ev = (0, Utils_1.makeEventBuffer)(logger);
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
@@ -35,7 +36,8 @@ const makeSocket = (config) => {
     /** WA noise protocol wrapper */
     const noise = (0, Utils_1.makeNoiseHandler)({
         keyPair: ephemeralKeyPair,
-        NOISE_HEADER: Defaults_1.NOISE_WA_HEADER,
+        NOISE_HEADER: config.mobile ? Defaults_1.MOBILE_NOISE_HEADER : Defaults_1.NOISE_WA_HEADER,
+        mobile: config.mobile,
         logger,
         routingInfo: (_b = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _b === void 0 ? void 0 : _b.routingInfo
     });
@@ -114,7 +116,7 @@ const makeSocket = (config) => {
         let onRecv;
         let onErr;
         try {
-            const result = await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
+            return await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
                 onRecv = resolve;
                 onErr = err => {
                     reject(err || new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed }));
@@ -123,7 +125,6 @@ const makeSocket = (config) => {
                 ws.on('close', onErr); // if the socket closes, you'll never receive the message
                 ws.off('error', onErr);
             });
-            return result;
         }
         finally {
             ws.off(`TAG:${msgId}`, onRecv);
@@ -137,10 +138,9 @@ const makeSocket = (config) => {
             node.attrs.id = generateMessageTag();
         }
         const msgId = node.attrs.id;
-        const [result] = await Promise.all([
-            waitForMessage(msgId, timeoutMs),
-            sendNode(node)
-        ]);
+        const wait = waitForMessage(msgId, timeoutMs);
+        await sendNode(node);
+        const result = await wait;
         if ('tag' in result) {
             (0, WABinary_1.assertNodeErrorFree)(result);
         }
@@ -159,7 +159,10 @@ const makeSocket = (config) => {
         logger.trace({ handshake }, 'handshake recv from WA');
         const keyEnc = await noise.processHandshake(handshake, creds.noiseKey);
         let node;
-        if (!creds.me) {
+        if (config.mobile) {
+            node = (0, Utils_1.generateMobileNode)(config);
+        }
+        else if (!creds.me) {
             node = (0, Utils_1.generateRegistrationNode)(creds, config);
             logger.info({ node }, 'not logged in, attempting registration...');
         }
@@ -229,11 +232,11 @@ const makeSocket = (config) => {
                 const l0 = frame.tag;
                 const l1 = frame.attrs || {};
                 const l2 = Array.isArray(frame.content) ? (_a = frame.content[0]) === null || _a === void 0 ? void 0 : _a.tag : '';
-                for (const key of Object.keys(l1)) {
+                Object.keys(l1).forEach(key => {
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered;
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]}`, frame) || anyTriggered;
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}`, frame) || anyTriggered;
-                }
+                });
                 anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered;
                 anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
                 if (!anyTriggered && logger.level === 'debug') {

package/lib/Socket/usync.d.ts

@@ -7,7 +7,7 @@ import { USyncQuery } from '../WAUSync';
 export declare const makeUSyncSocket: (config: SocketConfig) => {
     executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
     type: "md";
-    ws: import("./Client/websocket").WebSocketClient;
+    ws: any;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -22,8 +22,8 @@ export declare const makeUSyncSocket: (config: SocketConfig) => {
     signalRepository: import("../Types").SignalRepository;
     user: import("../Types").Contact | undefined;
     generateMessageTag: () => string;
-    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<any>;
-    waitForMessage: <T_1>(msgId: string, timeoutMs?: number | undefined) => Promise<any>;
+    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>;
+    waitForMessage: <T_1>(msgId: string, timeoutMs?: number | undefined) => Promise<T_1>;
     waitForSocketOpen: () => Promise<void>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
     sendNode: (frame: BinaryNode) => Promise<void>;
@@ -34,5 +34,5 @@ export declare const makeUSyncSocket: (config: SocketConfig) => {
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     requestPairingCode: (phoneNumber: string, pairCode: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number | undefined) => Promise<void>;
-    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
 };

package/lib/Store/index.d.ts

@@ -1,2 +1,3 @@
+import makeCacheManagerAuthState from './make-cache-manager-store';
 import makeInMemoryStore from './make-in-memory-store';
-export { makeInMemoryStore };
+export { makeInMemoryStore, makeCacheManagerAuthState };

package/lib/Store/index.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeInMemoryStore = void 0;
+exports.makeCacheManagerAuthState = exports.makeInMemoryStore = void 0;
+const make_cache_manager_store_1 = __importDefault(require("./make-cache-manager-store"));
+exports.makeCacheManagerAuthState = make_cache_manager_store_1.default;
 const make_in_memory_store_1 = __importDefault(require("./make-in-memory-store"));
 exports.makeInMemoryStore = make_in_memory_store_1.default;

package/lib/Store/make-cache-manager-store.d.ts

@@ -0,0 +1,14 @@
+import { Store } from 'cache-manager';
+import { AuthenticationCreds } from '../Types';
+declare const makeCacheManagerAuthState: (store: Store, sessionKey: string) => Promise<{
+    clearState: () => Promise<void>;
+    saveCreds: () => Promise<void>;
+    state: {
+        creds: AuthenticationCreds;
+        keys: {
+            get: (type: string, ids: string[]) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+}>;
+export default makeCacheManagerAuthState;

package/lib/Store/make-cache-manager-store.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cache_manager_1 = require("cache-manager");
+const WAProto_1 = require("../../WAProto");
+const Utils_1 = require("../Utils");
+const logger_1 = __importDefault(require("../Utils/logger"));
+const makeCacheManagerAuthState = async (store, sessionKey) => {
+    const defaultKey = (file) => `${sessionKey}:${file}`;
+    const databaseConn = await (0, cache_manager_1.caching)(store);
+    const writeData = async (file, data) => {
+        let ttl = undefined;
+        if (file === 'creds') {
+            ttl = 63115200; // 2 years
+        }
+        await databaseConn.set(defaultKey(file), JSON.stringify(data, Utils_1.BufferJSON.replacer), ttl);
+    };
+    const readData = async (file) => {
+        try {
+            const data = await databaseConn.get(defaultKey(file));
+            if (data) {
+                return JSON.parse(data, Utils_1.BufferJSON.reviver);
+            }
+            return null;
+        }
+        catch (error) {
+            logger_1.default.error(error);
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            return await databaseConn.del(defaultKey(file));
+        }
+        catch (_a) {
+            logger_1.default.error(`Error removing ${file} from session ${sessionKey}`);
+        }
+    };
+    const clearState = async () => {
+        try {
+            const result = await databaseConn.store.keys(`${sessionKey}*`);
+            await Promise.all(result.map(async (key) => await databaseConn.del(key)));
+        }
+        catch (err) {
+        }
+    };
+    const creds = (await readData('creds')) || (0, Utils_1.initAuthCreds)();
+    return {
+        clearState,
+        saveCreds: () => writeData('creds', creds),
+        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) {
+                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? writeData(key, value) : removeData(key));
+                        }
+                    }
+                    await Promise.all(tasks);
+                },
+            }
+        }
+    };
+};
+exports.default = makeCacheManagerAuthState;

package/lib/Store/make-in-memory-store.js

@@ -191,14 +191,16 @@ exports.default = (config) => {
                         const jid = (0, WABinary_1.jidNormalizedUser)(msg.key.remoteJid);
                         const list = assertMessageList(jid);
                         list.upsert(msg, 'append');
-                        if (type === 'notify' && !chats.get(jid)) {
-                            ev.emit('chats.upsert', [
-                                {
-                                    id: jid,
-                                    conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
-                                    unreadCount: 1
-                                }
-                            ]);
+                        if (type === 'notify') {
+                            if (!chats.get(jid)) {
+                                ev.emit('chats.upsert', [
+                                    {
+                                        id: jid,
+                                        conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
+                                        unreadCount: 1
+                                    }
+                                ]);
+                            }
                         }
                     }
                     break;

package/lib/Store/make-ordered-dictionary.js

@@ -56,9 +56,9 @@ function makeOrderedDictionary(idGetter) {
         },
         clear: () => {
             array.splice(0, array.length);
-            for (const key of Object.keys(dict)) {
+            Object.keys(dict).forEach(key => {
                 delete dict[key];
-            }
+            });
         },
         filter: (contain) => {
             let i = 0;

package/lib/Types/Auth.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import type { proto } from '../../WAProto';
+import { RegistrationOptions } from '../Socket/registration';
 import type { Contact } from './Contact';
 import type { MinimalMessage } from './Message';
 export type KeyPair = {
@@ -57,7 +58,12 @@ export type AuthenticationCreds = SignalCreds & {
     /** number of times history & app state has been synced */
     accountSyncCounter: number;
     accountSettings: AccountSettings;
+    deviceId: string;
+    phoneId: string;
+    identityId: Buffer;
     registered: boolean;
+    backupToken: Buffer;
+    registration: RegistrationOptions;
     pairingCode: string | undefined;
     lastPropHash: string | undefined;
     routingInfo: Buffer | undefined;

package/lib/Types/Chat.d.ts

@@ -19,10 +19,6 @@ export interface PresenceData {
     lastKnownPresence: WAPresence;
     lastSeen?: number;
 }
-export type BotListInfo = {
-    jid: string;
-    personaId: string;
-};
 export type ChatMutation = {
     syncAction: proto.ISyncActionData;
     index: string[];

package/lib/Types/Contact.d.ts

@@ -14,6 +14,6 @@ export interface Contact {
      * null => if the profile picture has not been set (default profile picture)
      * any other string => url of the profile picture
      */
-    imgUrl?: string | null;
+    imgUrl?: string | null | 'changed';
     status?: string;
 }

package/lib/Types/GroupMetadata.d.ts

@@ -3,28 +3,22 @@ export type GroupParticipant = (Contact & {
     isAdmin?: boolean;
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
-    phoneNumber?: string | undefined;
 });
 export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote' | 'modify';
 export type RequestJoinAction = 'created' | 'revoked' | 'rejected';
 export type RequestJoinMethod = 'invite_link' | 'linked_group_join' | 'non_admin_add' | undefined;
 export interface GroupMetadata {
     id: string;
-    /** group uses 'lid' or 'pn' to send messages */
-    addressingMode: "pn" | "lid";
     owner: string | undefined;
     subject: string;
     /** group subject owner */
     subjectOwner?: string;
-    subjectOwnerPhoneNumber?: string;
     /** group subject modification date */
     subjectTime?: number;
     creation?: number;
     desc?: string;
     descOwner?: string;
-    descOwnerPhoneNumber?: string;
     descId?: string;
-    descTime?: number;
     /** if this group is part of a community, it returns the jid of the community to which it belongs */
     linkedParent?: string;
     /** is set when the group only allows admins to change group settings */

package/lib/Types/Message.d.ts

@@ -23,15 +23,13 @@ export type WATextMessage = proto.Message.IExtendedTextMessage;
 export type WAContextInfo = proto.IContextInfo;
 export type WALocationMessage = proto.Message.ILocationMessage;
 export type WAGenericMediaMessage = proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
-export declare const WAMessageStubType: typeof proto.WebMessageInfo.StubType;
-export declare const WAMessageStatus: typeof proto.WebMessageInfo.Status;
-export type WAMediaPayloadURL = {
+export import WAMessageStubType = proto.WebMessageInfo.StubType;
+export import WAMessageStatus = proto.WebMessageInfo.Status;
+export type WAMediaUpload = Buffer | {
     url: URL | string;
-};
-export type WAMediaPayloadStream = {
+} | {
     stream: Readable;
 };
-export type WAMediaUpload = Buffer | WAMediaPayloadStream | WAMediaPayloadURL;
 /** Set of message types that are supported by the library */
 export type MessageType = keyof proto.Message;
 export type DownloadableMessage = {
@@ -330,35 +328,13 @@ export type MiscMessageGenerationOptions = MinimalRelayOptions & {
 export type MessageGenerationOptionsFromContent = MiscMessageGenerationOptions & {
     userJid: string;
 };
-export type PrepareStreamResult = {
-    type: 'prepare';
-    mediaKey: undefined;
-    encWriteStream: Buffer;
-    fileLength: number;
-    fileSha256: Buffer;
-    fileEncSha256: undefined;
-    bodyPath: string | undefined;
-    didSaveToTmpPath: boolean;
-};
-export type EncryptedStreamResult = {
-    type: 'encrypted';
-    mediaKey: Buffer;
-    originalFilePath: string | undefined;
-    encFilePath: string;
-    mac: Buffer;
-    fileEncSha256: Buffer;
-    fileSha256: Buffer;
-    fileLength: number;
-    didSaveToTmpPath: boolean;
-};
-export type StreamResult = PrepareStreamResult | EncryptedStreamResult;
 export type WAMediaUploadFunctionOpts = {
     fileEncSha256B64: string;
     mediaType: MediaType;
     newsletter?: boolean;
     timeoutMs?: number;
 };
-export type WAMediaUploadFunction = (encFilePath: string, opts: WAMediaUploadFunctionOpts) => Promise<{
+export type WAMediaUploadFunction = (readStream: Readable | Buffer, opts: WAMediaUploadFunctionOpts) => Promise<{
     mediaUrl: string;
     directPath: string;
     handle?: string;

package/lib/Types/Message.js

@@ -3,5 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WAMessageStatus = exports.WAMessageStubType = exports.WAProto = void 0;
 const WAProto_1 = require("../../WAProto");
 Object.defineProperty(exports, "WAProto", { enumerable: true, get: function () { return WAProto_1.proto; } });
+// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
 exports.WAMessageStubType = WAProto_1.proto.WebMessageInfo.StubType;
+// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
 exports.WAMessageStatus = WAProto_1.proto.WebMessageInfo.Status;

package/lib/Types/Socket.d.ts

@@ -21,9 +21,6 @@ export type CacheStore = {
     /** flush all data */
     flushAll(): void;
 };
-export type PatchedMessageWithRecipientJID = proto.IMessage & {
-    recipientJid?: string;
-};
 export type SocketConfig = {
     /** the WS url to connect to WA */
     waWebSocketUrl: string | URL;
@@ -33,9 +30,7 @@ export type SocketConfig = {
     defaultQueryTimeoutMs: number | undefined;
     /** ping-pong interval for WS connection */
     keepAliveIntervalMs: number;
-    /** should baileys use the mobile api instead of the multi device api
-    * @deprecated This feature has been removed
-    */
+    /** should baileys use the mobile api instead of the multi device api */
     mobile?: boolean;
     /** proxy agent */
     agent?: Agent;
@@ -103,7 +98,7 @@ export type SocketConfig = {
     /**
      * Optionally patch the message before sending out
      * */
-    patchMessageBeforeSending: (msg: proto.IMessage, recipientJids?: string[]) => Promise<PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID> | PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID;
+    patchMessageBeforeSending: (msg: proto.IMessage, recipientJids: string[]) => Promise<proto.IMessage> | proto.IMessage;
     /** verify app state MACs */
     appStateMacVerification: {
         patch: boolean;
@@ -120,4 +115,6 @@ export type SocketConfig = {
     /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
     cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>;
     makeSignalRepository: (auth: SignalAuthState) => SignalRepository;
+    /** Socket passthrough */
+    socket?: any;
 };

package/lib/Utils/auth-utils.d.ts

@@ -6,7 +6,7 @@ import { ILogger } from './logger';
  * @param logger to log trace events
  * @param _cache cache store to use
  */
-export declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger?: ILogger, _cache?: CacheStore): SignalKeyStore;
+export declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger: ILogger, _cache?: CacheStore): SignalKeyStore;
 /**
  * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
  * this allows batch read & write operations & improves the performance of the lib