@queenanya/baileys 6.9.2 → 7.0.0

package/lib/Types/Label.d.ts

@@ -10,6 +10,17 @@ export interface Label {
     /** WhatsApp has 5 predefined labels (New customer, New order & etc) */
     predefinedId?: string;
 }
+export interface LabelActionBody {
+    id: string;
+    /** Label name */
+    name?: string;
+    /** Label color ID */
+    color?: number;
+    /** Is label has been deleted */
+    deleted?: boolean;
+    /** WhatsApp has 5 predefined labels (New customer, New order & etc) */
+    predefinedId?: number;
+}
 /** WhatsApp has 20 predefined colors */
 export declare enum LabelColor {
     Color1 = 0,

package/lib/Types/Message.d.ts

@@ -7,6 +7,7 @@ import type { Readable } from 'stream';
 import type { URL } from 'url';
 import { proto } from '../../WAProto';
 import { MEDIA_HKDF_KEY_MAPPING } from '../Defaults';
+import { BinaryNode } from '../WABinary';
 import type { GroupMetadata } from './GroupMetadata';
 import { CacheStore } from './Socket';
 export { proto as WAProto };
@@ -14,7 +15,9 @@ export type WAMessage = proto.IWebMessageInfo;
 export type WAMessageContent = proto.IMessage;
 export type WAContactMessage = proto.Message.IContactMessage;
 export type WAContactsArrayMessage = proto.Message.IContactsArrayMessage;
-export type WAMessageKey = proto.IMessageKey;
+export type WAMessageKey = proto.IMessageKey & {
+    server_id?: string;
+};
 export type WATextMessage = proto.Message.IExtendedTextMessage;
 export type WAContextInfo = proto.IContextInfo;
 export type WALocationMessage = proto.Message.ILocationMessage;
@@ -63,26 +66,9 @@ type Contextable = {
 type ViewOnce = {
     viewOnce?: boolean;
 };
-type Buttonable = {
-    /** add buttons to the message  */
-    buttons?: proto.Message.ButtonsMessage.IButton[];
-};
-type Templatable = {
-    /** add buttons to the message (conflicts with normal buttons)*/
-    templateButtons?: proto.IHydratedTemplateButton[];
-    footer?: string;
-};
 type Editable = {
     edit?: WAMessageKey;
 };
-type Listable = {
-    /** Sections of the List */
-    sections?: proto.Message.ListMessage.ISection[];
-    /** Title of a List Message only */
-    title?: string;
-    /** Text of the bnutton on the list (required) */
-    buttonText?: string;
-};
 type WithDimensions = {
     width?: number;
     height?: number;
@@ -93,6 +79,7 @@ export type PollMessageOptions = {
     values: string[];
     /** 32 byte message secret to encrypt poll selections */
     messageSecret?: Uint8Array;
+    toAnnouncementGroup?: boolean;
 };
 type SharePhoneNumber = {
     sharePhoneNumber: boolean;
@@ -105,14 +92,14 @@ export type AnyMediaMessageContent = (({
     image: WAMediaUpload;
     caption?: string;
     jpegThumbnail?: string;
-} & Mentionable & Contextable & Buttonable & Templatable & WithDimensions) | ({
+} & Mentionable & Contextable & WithDimensions) | ({
     video: WAMediaUpload;
     caption?: string;
     gifPlayback?: boolean;
     jpegThumbnail?: string;
     /** if set to true, will send as a `video note` */
     ptv?: boolean;
-} & Mentionable & Contextable & Buttonable & Templatable & WithDimensions) | {
+} & Mentionable & Contextable & WithDimensions) | {
     audio: WAMediaUpload;
     /** if set to true, will send as a `voice note` */
     ptt?: boolean;
@@ -126,7 +113,7 @@ export type AnyMediaMessageContent = (({
     mimetype: string;
     fileName?: string;
     caption?: string;
-} & Contextable & Buttonable & Templatable)) & {
+} & Contextable)) & {
     mimetype?: string;
 } & Editable;
 export type ButtonReplyInfo = {
@@ -134,15 +121,22 @@ export type ButtonReplyInfo = {
     id: string;
     index: number;
 };
+export type GroupInviteInfo = {
+    inviteCode: string;
+    inviteExpiration: number;
+    text: string;
+    jid: string;
+    subject: string;
+};
 export type WASendableProduct = Omit<proto.Message.ProductMessage.IProductSnapshot, 'productImage'> & {
     productImage: WAMediaUpload;
 };
 export type AnyRegularMessageContent = (({
     text: string;
     linkPreview?: WAUrlInfo | null;
-} & Mentionable & Contextable & Buttonable & Templatable & Listable & Editable) | AnyMediaMessageContent | ({
+} & Mentionable & Contextable & Editable) | AnyMediaMessageContent | ({
     poll: PollMessageOptions;
-} & Mentionable & Contextable & Buttonable & Templatable & Editable) | {
+} & Mentionable & Contextable & Editable) | {
     contacts: {
         displayName?: string;
         contacts: proto.Message.IContactMessage[];
@@ -154,8 +148,19 @@ export type AnyRegularMessageContent = (({
 } | {
     buttonReply: ButtonReplyInfo;
     type: 'template' | 'plain';
+} | {
+    groupInvite: GroupInviteInfo;
 } | {
     listReply: Omit<proto.Message.IListResponseMessage, 'contextInfo'>;
+} | {
+    pin: WAMessageKey;
+    type: proto.PinInChat.Type;
+    /**
+     * 24 hours, 7 days, 30 days
+     */
+    time?: 86400 | 604800 | 2592000;
+} | {
+    unpin: WAMessageKey;
 } | {
     product: WASendableProduct;
     businessOwnerJid?: string;
@@ -175,8 +180,8 @@ export type GroupMetadataParticipants = Pick<GroupMetadata, 'participants'>;
 type MinimalRelayOptions = {
     /** override the message ID with a custom provided string */
     messageId?: string;
-    /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
-    cachedGroupMetadata?: (jid: string) => Promise<GroupMetadataParticipants | undefined>;
+    /** should we use group metadata cache, or fetch afresh from the server; default assumed to be "true" */
+    useCachedGroupMetadata?: boolean;
 };
 export type MessageRelayOptions = MinimalRelayOptions & {
     /** only send to a specific participant; used when a message decryption fails for a single user */
@@ -188,6 +193,7 @@ export type MessageRelayOptions = MinimalRelayOptions & {
     additionalAttributes?: {
         [_: string]: string;
     };
+    additionalNodes?: BinaryNode[];
     /** should we use the devices cache, or fetch afresh from the server; default assumed to be "true" */
     useUserDevicesCache?: boolean;
     /** jid list of participants for status@broadcast */
@@ -214,13 +220,16 @@ export type MiscMessageGenerationOptions = MinimalRelayOptions & {
 export type MessageGenerationOptionsFromContent = MiscMessageGenerationOptions & {
     userJid: string;
 };
-export type WAMediaUploadFunction = (readStream: Readable, opts: {
+export type WAMediaUploadFunctionOpts = {
     fileEncSha256B64: string;
     mediaType: MediaType;
+    newsletter?: boolean;
     timeoutMs?: number;
-}) => Promise<{
+};
+export type WAMediaUploadFunction = (readStream: Readable | Buffer, opts: WAMediaUploadFunctionOpts) => Promise<{
     mediaUrl: string;
     directPath: string;
+    handle?: string;
 }>;
 export type MediaGenerationOptions = {
     logger?: Logger;
@@ -231,10 +240,13 @@ export type MediaGenerationOptions = {
     mediaUploadTimeoutMs?: number;
     options?: AxiosRequestConfig;
     backgroundColor?: string;
+    /** The message is for newsletter? */
+    newsletter?: boolean;
     font?: number;
 };
 export type MessageContentGenerationOptions = MediaGenerationOptions & {
     getUrlInfo?: (text: string) => Promise<WAUrlInfo | undefined>;
+    getProfilePicUrl?: (jid: string, type: 'image' | 'preview') => Promise<string | undefined>;
 };
 export type MessageGenerationOptions = MessageContentGenerationOptions & MessageGenerationOptionsFromContent;
 /**

package/lib/Types/Newsletter.d.ts

@@ -0,0 +1,79 @@
+import { proto } from '../../WAProto';
+export type NewsletterReactionMode = 'ALL' | 'BASIC' | 'NONE';
+export type NewsletterState = 'ACTIVE' | 'GEOSUSPENDED' | 'SUSPENDED';
+export type NewsletterVerification = 'VERIFIED' | 'UNVERIFIED';
+export type NewsletterMute = 'ON' | 'OFF' | 'UNDEFINED';
+export type NewsletterViewRole = 'ADMIN' | 'GUEST' | 'OWNER' | 'SUBSCRIBER';
+export type NewsletterViewerMetadata = {
+    mute: NewsletterMute;
+    view_role: NewsletterViewRole;
+};
+export type NewsletterMetadata = {
+    /**jid of newsletter */
+    id: string;
+    /**state of newsletter */
+    state: NewsletterState;
+    /**creation timestamp of newsletter */
+    creation_time: number;
+    /**name of newsletter */
+    name: string;
+    /**timestamp of last name modification of newsletter */
+    nameTime: number;
+    /**description of newsletter */
+    description: string;
+    /**timestamp of last description modification of newsletter */
+    descriptionTime: number;
+    /**invite code of newsletter */
+    invite: string;
+    /**i dont know */
+    handle: null;
+    /**direct path of picture */
+    picture: string | null;
+    /**direct path of picture preview (lower quality) */
+    preview: string | null;
+    /**reaction mode of newsletter */
+    reaction_codes?: NewsletterReactionMode;
+    /**subscribers count of newsletter */
+    subscribers: number;
+    /**verification state of newsletter */
+    verification: NewsletterVerification;
+    /**viewer metadata */
+    viewer_metadata: NewsletterViewerMetadata;
+};
+export type SubscriberAction = 'promote' | 'demote';
+export type ReactionModeUpdate = {
+    reaction_codes: {
+        blocked_codes: null;
+        enabled_ts_sec: null;
+        value: NewsletterReactionMode;
+    };
+};
+/**only exists reaction mode update */
+export type NewsletterSettingsUpdate = ReactionModeUpdate;
+export type NewsletterReaction = {
+    count: number;
+    code: string;
+};
+export type NewsletterFetchedUpdate = {
+    /**id of message in newsletter, starts from 100 */
+    server_id: string;
+    /**count of views in this message */
+    views?: number;
+    /**reactions in this message */
+    reactions: NewsletterReaction[];
+    /**the message, if you requested only updates, you will not receive message */
+    message?: proto.IWebMessageInfo;
+};
+export declare enum MexOperations {
+    PROMOTE = "NotificationNewsletterAdminPromote",
+    DEMOTE = "NotificationNewsletterAdminDemote",
+    UPDATE = "NotificationNewsletterUpdate"
+}
+export declare enum XWAPaths {
+    PROMOTE = "xwa2_notify_newsletter_admin_promote",
+    DEMOTE = "xwa2_notify_newsletter_admin_demote",
+    ADMIN_COUNT = "xwa2_newsletter_admin",
+    CREATE = "xwa2_newsletter_create",
+    NEWSLETTER = "xwa2_newsletter",
+    METADATA_UPDATE = "xwa2_notify_newsletter_on_metadata_update"
+}

package/lib/Types/Newsletter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XWAPaths = exports.MexOperations = void 0;
+var MexOperations;
+(function (MexOperations) {
+    MexOperations["PROMOTE"] = "NotificationNewsletterAdminPromote";
+    MexOperations["DEMOTE"] = "NotificationNewsletterAdminDemote";
+    MexOperations["UPDATE"] = "NotificationNewsletterUpdate";
+})(MexOperations = exports.MexOperations || (exports.MexOperations = {}));
+var XWAPaths;
+(function (XWAPaths) {
+    XWAPaths["PROMOTE"] = "xwa2_notify_newsletter_admin_promote";
+    XWAPaths["DEMOTE"] = "xwa2_notify_newsletter_admin_demote";
+    XWAPaths["ADMIN_COUNT"] = "xwa2_newsletter_admin";
+    XWAPaths["CREATE"] = "xwa2_newsletter_create";
+    XWAPaths["NEWSLETTER"] = "xwa2_newsletter";
+    XWAPaths["METADATA_UPDATE"] = "xwa2_notify_newsletter_on_metadata_update";
+})(XWAPaths = exports.XWAPaths || (exports.XWAPaths = {}));

package/lib/Types/Socket.d.ts

@@ -6,6 +6,7 @@ import type { Logger } from 'pino';
 import type { URL } from 'url';
 import { proto } from '../../WAProto';
 import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth';
+import { GroupMetadata } from './GroupMetadata';
 import { MediaConnInfo } from './Message';
 import { SignalRepository } from './Signal';
 export type WAVersion = [number, number, number];
@@ -71,10 +72,14 @@ export type SocketConfig = {
     userDevicesCache?: CacheStore;
     /** cache to store call offers */
     callOfferCache?: CacheStore;
+    /** cache to track placeholder resends */
+    placeholderResendCache?: CacheStore;
     /** width for link preview images */
     linkPreviewImageThumbnailWidth: number;
     /** Should Baileys ask the phone for full history, will be received async */
     syncFullHistory: boolean;
+    /** Ignore Message when offline, default is false */
+    ignoreMsgLoading: boolean;
     /** Should baileys fire init queries automatically, default true */
     fireInitQueries: boolean;
     /**
@@ -105,6 +110,8 @@ export type SocketConfig = {
      * (solves the "this message can take a while" issue) can be retried
      * */
     getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>;
+    /** 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/Types/index.d.ts

@@ -4,6 +4,7 @@ export * from './Chat';
 export * from './Contact';
 export * from './State';
 export * from './Message';
+export * from './Newsletter';
 export * from './Socket';
 export * from './Events';
 export * from './Product';
@@ -14,6 +15,14 @@ import { SocketConfig } from './Socket';
 export type UserFacingSocketConfig = Partial<SocketConfig> & {
     auth: AuthenticationState;
 };
+/** Other Browser Support for Paircode */
+export type BrowsersMap = {
+    ubuntu(browser: string): [string, string, string];
+    macOS(browser: string): [string, string, string];
+    baileys(browser: string): [string, string, string];
+    windows(browser: string): [string, string, string];
+    appropriate(browser: string): [string, string, string];
+};
 export declare enum DisconnectReason {
     connectionClosed = 428,
     connectionLost = 408,

package/lib/Types/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./Chat"), exports);
 __exportStar(require("./Contact"), exports);
 __exportStar(require("./State"), exports);
 __exportStar(require("./Message"), exports);
+__exportStar(require("./Newsletter"), exports);
 __exportStar(require("./Socket"), exports);
 __exportStar(require("./Events"), exports);
 __exportStar(require("./Product"), exports);

package/lib/Utils/auth-utils.js

@@ -200,6 +200,7 @@ const initAuthCreds = () => {
         registration: {},
         pairingCode: undefined,
         lastPropHash: undefined,
+        routingInfo: undefined,
     };
 };
 exports.initAuthCreds = initAuthCreds;

package/lib/Utils/chat-utils.js

@@ -491,6 +491,22 @@ const chatModificationToAppPatch = (mod, jid) => {
             operation: OP.SET,
         };
     }
+    else if ('addLabel' in mod) {
+        patch = {
+            syncAction: {
+                labelEditAction: {
+                    name: mod.addLabel.name,
+                    color: mod.addLabel.color,
+                    predefinedId: mod.addLabel.predefinedId,
+                    deleted: mod.addLabel.deleted
+                }
+            },
+            index: ['label_edit', mod.addLabel.id],
+            type: 'regular',
+            apiVersion: 3,
+            operation: OP.SET,
+        };
+    }
     else if ('addChatLabel' in mod) {
         patch = {
             syncAction: {

package/lib/Utils/crypto.d.ts

@@ -38,4 +38,4 @@ export declare function hkdf(buffer: Uint8Array | Buffer, expandedLength: number
     salt?: Buffer;
     info?: string;
 }): Buffer;
-export declare function derivePairingCodeKey(pairingCode: string, salt: Buffer): Buffer;
+export declare function derivePairingCodeKey(pairingCode: string, salt: Buffer): Promise<Buffer>;

package/lib/Utils/crypto.js

@@ -30,7 +30,9 @@ exports.derivePairingCodeKey = exports.hkdf = exports.md5 = exports.sha256 = exp
 const crypto_1 = require("crypto");
 const futoin_hkdf_1 = __importDefault(require("futoin-hkdf"));
 const libsignal = __importStar(require("libsignal"));
+const util_1 = require("util");
 const Defaults_1 = require("../Defaults");
+const pbkdf2Promise = (0, util_1.promisify)(crypto_1.pbkdf2);
 /** prefix version byte to the pub keys, required for some curve crypto functions */
 const generateSignalPubKey = (pubKey) => (pubKey.length === 33
     ? pubKey
@@ -145,7 +147,7 @@ function hkdf(buffer, expandedLength, info) {
     return (0, futoin_hkdf_1.default)(!Buffer.isBuffer(buffer) ? Buffer.from(buffer) : buffer, expandedLength, info);
 }
 exports.hkdf = hkdf;
-function derivePairingCodeKey(pairingCode, salt) {
-    return (0, crypto_1.pbkdf2Sync)(pairingCode, salt, 2 << 16, 32, 'sha256');
+async function derivePairingCodeKey(pairingCode, salt) {
+    return await pbkdf2Promise(pairingCode, salt, 2 << 16, 32, 'sha256');
 }
 exports.derivePairingCodeKey = derivePairingCodeKey;

package/lib/Utils/decode-wa-message.d.ts

@@ -2,6 +2,7 @@ import { Logger } from 'pino';
 import { proto } from '../../WAProto';
 import { SignalRepository } from '../Types';
 import { BinaryNode } from '../WABinary';
+export declare const NO_MESSAGE_FOUND_ERROR_TEXT = "Message absent from node";
 /**
  * Decode the received node as a message.
  * @note this will only parse the message, not decrypt it

package/lib/Utils/decode-wa-message.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decryptMessageNode = exports.decodeMessageNode = void 0;
+exports.decryptMessageNode = exports.decodeMessageNode = exports.NO_MESSAGE_FOUND_ERROR_TEXT = void 0;
 const boom_1 = require("@hapi/boom");
 const WAProto_1 = require("../../WAProto");
 const WABinary_1 = require("../WABinary");
 const generics_1 = require("./generics");
-const NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node';
+exports.NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node';
 /**
  * Decode the received node as a message.
  * @note this will only parse the message, not decrypt it
  */
 function decodeMessageNode(stanza, meId, meLid) {
+    var _a, _b, _c, _d;
     let msgType;
     let chatId;
     let author;
@@ -54,6 +55,11 @@ function decodeMessageNode(stanza, meId, meLid) {
         author = participant;
         chatId = from;
     }
+    else if ((0, WABinary_1.isJidNewsletter)(from)) {
+        msgType = 'newsletter';
+        author = from;
+        chatId = from;
+    }
     else if ((0, WABinary_1.isJidBroadcast)(from)) {
         if (!participant) {
             throw new boom_1.Boom('No participant in group message');
@@ -68,16 +74,22 @@ function decodeMessageNode(stanza, meId, meLid) {
         chatId = from;
         author = participant;
     }
+    else if ((0, WABinary_1.isJidNewsletter)(from)) {
+        msgType = 'newsletter';
+        author = from;
+        chatId = from;
+    }
     else {
         throw new boom_1.Boom('Unknown message type', { data: stanza });
     }
-    const fromMe = ((0, WABinary_1.isLidUser)(from) ? isMeLid : isMe)(stanza.attrs.participant || stanza.attrs.from);
-    const pushname = stanza.attrs.notify;
+    const fromMe = (0, WABinary_1.isJidNewsletter)(from) ? !!((_a = stanza.attrs) === null || _a === void 0 ? void 0 : _a.is_sender) || false : ((0, WABinary_1.isLidUser)(from) ? isMeLid : isMe)(stanza.attrs.participant || stanza.attrs.from);
+    const pushname = (_b = stanza === null || stanza === void 0 ? void 0 : stanza.attrs) === null || _b === void 0 ? void 0 : _b.notify;
     const key = {
         remoteJid: chatId,
         fromMe,
         id: msgId,
-        participant
+        participant,
+        server_id: (_c = stanza.attrs) === null || _c === void 0 ? void 0 : _c.server_id
     };
     const fullMessage = {
         key,
@@ -85,6 +97,9 @@ function decodeMessageNode(stanza, meId, meLid) {
         pushName: pushname,
         broadcast: (0, WABinary_1.isJidBroadcast)(from)
     };
+    if (msgType === 'newsletter') {
+        fullMessage.newsletterServerId = +((_d = stanza.attrs) === null || _d === void 0 ? void 0 : _d.server_id);
+    }
     if (key.fromMe) {
         fullMessage.status = WAProto_1.proto.WebMessageInfo.Status.SERVER_ACK;
     }
@@ -104,14 +119,34 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
         async decrypt() {
             var _a;
             let decryptables = 0;
-            if (Array.isArray(stanza.content)) {
+            async function processSenderKeyDistribution(msg) {
+                if (msg.senderKeyDistributionMessage) {
+                    try {
+                        await repository.processSenderKeyDistributionMessage({
+                            authorJid: author,
+                            item: msg.senderKeyDistributionMessage
+                        });
+                    }
+                    catch (err) {
+                        logger.error({ key: fullMessage.key, err }, 'failed to process senderKeyDistribution');
+                    }
+                }
+            }
+            if ((0, WABinary_1.isJidNewsletter)(fullMessage.key.remoteJid)) {
+                const node = (0, WABinary_1.getBinaryNodeChild)(stanza, 'plaintext');
+                const msg = WAProto_1.proto.Message.decode(node === null || node === void 0 ? void 0 : node.content);
+                await processSenderKeyDistribution(msg);
+                fullMessage.message = msg;
+                decryptables += 1;
+            }
+            else if (Array.isArray(stanza.content)) {
                 for (const { tag, attrs, content } of stanza.content) {
                     if (tag === 'verified_name' && content instanceof Uint8Array) {
                         const cert = WAProto_1.proto.VerifiedNameCertificate.decode(content);
                         const details = WAProto_1.proto.VerifiedNameCertificate.Details.decode(cert.details);
                         fullMessage.verifiedBizName = details.verifiedName;
                     }
-                    if (tag !== 'enc') {
+                    if (tag !== 'enc' && tag !== 'plaintext') {
                         continue;
                     }
                     if (!(content instanceof Uint8Array)) {
@@ -120,7 +155,7 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                     decryptables += 1;
                     let msgBuffer;
                     try {
-                        const e2eType = attrs.type;
+                        const e2eType = tag === 'plaintext' ? 'plaintext' : attrs.type;
                         switch (e2eType) {
                             case 'skmsg':
                                 msgBuffer = await repository.decryptGroupMessage({
@@ -138,22 +173,15 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                                     ciphertext: content
                                 });
                                 break;
+                            case 'plaintext':
+                                msgBuffer = content;
+                                break;
                             default:
                                 throw new Error(`Unknown e2e type: ${e2eType}`);
                         }
-                        let msg = WAProto_1.proto.Message.decode((0, generics_1.unpadRandomMax16)(msgBuffer));
-                        msg = ((_a = msg.deviceSentMessage) === null || _a === void 0 ? void 0 : _a.message) || msg;
-                        if (msg.senderKeyDistributionMessage) {
-                            try {
-                                await repository.processSenderKeyDistributionMessage({
-                                    authorJid: author,
-                                    item: msg.senderKeyDistributionMessage
-                                });
-                            }
-                            catch (err) {
-                                logger.error({ key: fullMessage.key, err }, 'failed to decrypt message');
-                            }
-                        }
+                        let msg = WAProto_1.proto.Message.decode(tag === 'plaintext' ? msgBuffer : (0, generics_1.unpadRandomMax16)(msgBuffer));
+                        msg = ((_a = msg === null || msg === void 0 ? void 0 : msg.deviceSentMessage) === null || _a === void 0 ? void 0 : _a.message) || msg;
+                        await processSenderKeyDistribution(msg);
                         if (fullMessage.message) {
                             Object.assign(fullMessage.message, msg);
                         }
@@ -171,7 +199,7 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
             // if nothing was found to decrypt
             if (!decryptables) {
                 fullMessage.messageStubType = WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT;
-                fullMessage.messageStubParameters = [NO_MESSAGE_FOUND_ERROR_TEXT, JSON.stringify(stanza, generics_1.BufferJSON.replacer)];
+                fullMessage.messageStubParameters = [exports.NO_MESSAGE_FOUND_ERROR_TEXT];
             }
         }
     };

package/lib/Utils/generics.d.ts

@@ -2,16 +2,20 @@
 import { AxiosRequestConfig } from 'axios';
 import { Logger } from 'pino';
 import { proto } from '../../WAProto';
-import { BaileysEventEmitter, BaileysEventMap, WACallUpdateType, WAVersion } from '../Types';
+import { BaileysEventEmitter, BaileysEventMap, BrowsersMap, WACallUpdateType, WAVersion } from '../Types';
 import { BinaryNode } from '../WABinary';
-export declare const Browsers: {
-    ubuntu: (browser: any) => [string, string, string];
-    macOS: (browser: any) => [string, string, string];
-    baileys: (browser: any) => [string, string, string];
-    windows: (browser: any) => [string, string, string];
-    /** The appropriate browser based on your OS & release */
-    appropriate: (browser: any) => [string, string, string];
-};
+/**
+const COMPANION_PLATFORM_MAP = {
+    'Chrome': '49',
+    'Edge': '50',
+    'Firefox': '51',
+    'Opera': '53',
+    'Safari': '54'
+}
+*/
+export declare const Browsers: BrowsersMap;
+/** Other Browser Support for Paircode */
+export declare const getPlatformId: (browser: string) => any;
 export declare const BufferJSON: {
     replacer: (k: any, value: any) => any;
     reviver: (_: any, value: any) => any;
@@ -20,6 +24,7 @@ export declare const getKeyAuthor: (key: proto.IMessageKey | undefined | null, m
 export declare const writeRandomPadMax16: (msg: Uint8Array) => Buffer;
 export declare const unpadRandomMax16: (e: Uint8Array | Buffer) => Uint8Array;
 export declare const encodeWAMessage: (message: proto.IMessage) => Buffer;
+export declare const encodeNewsletterMessage: (message: proto.IMessage) => Uint8Array;
 export declare const generateRegistrationId: () => number;
 export declare const encodeBigEndian: (e: number, t?: number) => Uint8Array;
 export declare const toNumber: (t: Long | number | null | undefined) => number;
@@ -38,15 +43,30 @@ export declare const delayCancellable: (ms: number) => {
     cancel: () => void;
 };
 export declare function promiseTimeout<T>(ms: number | undefined, promise: (resolve: (v: T) => void, reject: (error: any) => void) => void): Promise<T>;
+export declare const generateMessageIDV2: (userId?: string) => string;
+export declare const generateMessageIDV3: (userId?: string) => string;
 export declare const generateMessageID: () => string;
 export declare function bindWaitForEvent<T extends keyof BaileysEventMap>(ev: BaileysEventEmitter, event: T): (check: (u: BaileysEventMap[T]) => boolean | undefined, timeoutMs?: number) => Promise<void>;
 export declare const bindWaitForConnectionUpdate: (ev: BaileysEventEmitter) => (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number) => Promise<void>;
 export declare const printQRIfNecessaryListener: (ev: BaileysEventEmitter, logger: Logger) => void;
 /**
- * utility that fetches latest baileys version from the master branch.
+ * utility that fetches latest baileys version from the main branch.
  * Use to ensure your WA connection is always on the latest version
  */
 export declare const fetchLatestBaileysVersion: (options?: AxiosRequestConfig<any>) => Promise<{
+    version: number[];
+    isLatest: boolean;
+    error?: undefined;
+} | {
+    version: WAVersion;
+    isLatest: boolean;
+    error: any;
+}>;
+/**
+ * utility that fetches latest baileys version from the master branch.
+ * Use to ensure your WA connection is always on the latest version
+ */
+export declare const fetchLatestBaileysVersion2: (options?: AxiosRequestConfig<any>) => Promise<{
     version: WAVersion;
     isLatest: boolean;
     error?: undefined;