@fer2809fl/baileys 7.0.1 → 7.0.4

package/lib/Utils/noise-handler.d.ts

@@ -14,7 +14,7 @@ export declare const makeNoiseHandler: ({ keyPair: { private: privateKey, public
     mixIntoKey: (data: Uint8Array) => void;
     finishInit: () => Promise<void>;
     processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => Uint8Array<ArrayBufferLike>;
-    encodeFrame: (data: Buffer | Uint8Array) => Buffer<ArrayBuffer>;
+    encodeFrame: (data: Buffer | Uint8Array) => Buffer;
     decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => Promise<void>;
 };
 //# sourceMappingURL=noise-handler.d.ts.map

package/lib/Utils/process-message.js

@@ -1,4 +1,3 @@
-import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageStubType } from '../Types/index.js';
 import { getContentType, normalizeMessageContent } from '../Utils/messages.js';
@@ -6,7 +5,6 @@ import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJid
 import { aesDecryptGCM, hmacSign } from './crypto.js';
 import { getKeyAuthor, toNumber } from './generics.js';
 import { downloadAndProcessHistorySyncNotification } from './history.js';
-import { buildMergedTcTokenIndexWrite, resolveTcTokenJid } from './tc-token-utils.js';
 const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_GROUP_VIDEO,
     WAMessageStubType.CALL_MISSED_GROUP_VOICE,
@@ -14,53 +12,6 @@ const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_VOICE
 ]);
 const REAL_MSG_REQ_ME_STUB_TYPES = new Set([WAMessageStubType.GROUP_PARTICIPANT_ADD]);
-async function storeTcTokensFromHistorySync(chats, signalRepository, keyStore, logger) {
-    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
-    const candidates = [];
-    for (const chat of chats) {
-        const ts = chat.tcTokenTimestamp ? toNumber(chat.tcTokenTimestamp) : 0;
-        if (chat.tcToken?.length && ts > 0) {
-            const jid = jidNormalizedUser(chat.id);
-            const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
-            candidates.push({
-                storageJid,
-                token: Buffer.from(chat.tcToken),
-                ts,
-                senderTs: chat.tcTokenSenderTimestamp ? toNumber(chat.tcTokenSenderTimestamp) : undefined
-            });
-        }
-    }
-    if (!candidates.length) {
-        return;
-    }
-    const jids = candidates.map(c => c.storageJid);
-    const existing = await keyStore.get('tctoken', jids);
-    const entries = {};
-    for (const c of candidates) {
-        const existingEntry = existing[c.storageJid];
-        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
-        if (existingTs > 0 && existingTs >= c.ts) {
-            continue;
-        }
-        entries[c.storageJid] = {
-            ...existingEntry,
-            token: c.token,
-            timestamp: String(c.ts),
-            ...(c.senderTs !== undefined ? { senderTimestamp: c.senderTs } : {})
-        };
-    }
-    if (Object.keys(entries).length) {
-        logger?.debug({ count: Object.keys(entries).length }, 'storing tctokens from history sync');
-        try {
-            // Include updated __index so cross-session pruning picks these JIDs up.
-            const indexWrite = await buildMergedTcTokenIndexWrite(keyStore, Object.keys(entries));
-            await keyStore.set({ tctoken: { ...entries, ...indexWrite } });
-        }
-        catch (err) {
-            logger?.warn({ err }, 'failed to store tctokens from history sync');
-        }
-    }
-}
 /** Cleans a received message to further processing */
 export const cleanMessage = (message, meId, meLid) => {
     // ensure remoteJid and participant doesn't have device or agent in it
@@ -122,17 +73,7 @@ export const shouldIncrementChatUnread = (message) => !message.key.fromMe && !me
  * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
  */
 export const getChatId = ({ remoteJid, participant, fromMe }) => {
-    if (!remoteJid) {
-        throw new Boom('Cannot derive chat id: message key is missing remoteJid', {
-            data: { remoteJid, participant, fromMe }
-        });
-    }
     if (isJidBroadcast(remoteJid) && !isJidStatusBroadcast(remoteJid) && !fromMe) {
-        if (!participant) {
-            throw new Boom('Cannot derive chat id: broadcast message key is missing participant', {
-                data: { remoteJid, fromMe }
-            });
-        }
         return participant;
     }
     return remoteJid;
@@ -205,39 +146,6 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
     }
     const protocolMsg = content?.protocolMessage;
     if (protocolMsg) {
-        // Mirror whatsmeow's `handleProtocolMessage` guard, but applied only to
-        // the protocol message types that originate from our own device — an
-        // attacker could otherwise spoof any of these to manipulate local state.
-        //
-        // Self-only types (drop if `!fromMe`):
-        //   - HISTORY_SYNC_NOTIFICATION                 (our phone driving history sync)
-        //   - APP_STATE_SYNC_KEY_SHARE                  (key share between our devices)
-        //   - LID_MIGRATION_MAPPING_SYNC                (server-initiated via our phone)
-        //   - PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE (response from our phone to our PDO request)
-        //
-        // Cross-user types (must NOT be dropped — legitimately arrive from others):
-        //   - REVOKE
-        //   - MESSAGE_EDIT
-        //   - EPHEMERAL_SETTING
-        //   - GROUP_MEMBER_LABEL_CHANGE
-        //
-        // See https://github.com/tulir/whatsmeow/blob/8d3700152a/message.go#L842-L845
-        // for the reference architecture — whatsmeow's `handleProtocolMessage`
-        // only contains self-only types because edits are unwrapped from
-        // `EditedMessage` BEFORE this dispatch and revokes aren't routed here.
-        const SELF_ONLY_TYPES = new Set([
-            proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION,
-            proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE,
-            proto.Message.ProtocolMessage.Type.LID_MIGRATION_MAPPING_SYNC,
-            proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE
-        ]);
-        if (protocolMsg.type !== null &&
-            protocolMsg.type !== undefined &&
-            SELF_ONLY_TYPES.has(protocolMsg.type) &&
-            !message.key.fromMe) {
-            logger?.warn({ msgId: message.key.id, type: protocolMsg.type, from: message.key.participant || message.key.remoteJid }, 'dropping spoofed self-only protocolMessage from non-self origin');
-            return;
-        }
         switch (protocolMsg.type) {
             case proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION:
                 const histNotification = protocolMsg.historySyncNotification;
@@ -266,11 +174,9 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                             .storeLIDPNMappings(data.lidPnMappings)
                             .catch(err => logger?.warn({ err }, 'failed to store LID-PN mappings from history sync'));
                     }
-                    await storeTcTokensFromHistorySync(data.chats, signalRepository, keyStore, logger);
                     ev.emit('messaging-history.set', {
                         ...data,
                         isLatest: histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND ? isLatest : undefined,
-                        chunkOrder: histNotification.chunkOrder,
                         peerDataRequestSessionId: histNotification.peerDataRequestSessionId
                     });
                 }
@@ -477,19 +383,12 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             id: jid,
             author: message.key.participant,
             authorPn: message.key.participantAlt,
-            authorUsername: message.key.participantUsername,
             participants,
             action
         });
         const emitGroupUpdate = (update) => {
             ev.emit('groups.update', [
-                {
-                    id: jid,
-                    ...update,
-                    author: message.key.participant ?? undefined,
-                    authorPn: message.key.participantAlt,
-                    authorUsername: message.key.participantUsername
-                }
+                { id: jid, ...update, author: message.key.participant ?? undefined, authorPn: message.key.participantAlt }
             ]);
         };
         const emitGroupRequestJoin = (participant, action, method) => {
@@ -497,7 +396,6 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                 id: jid,
                 author: message.key.participant,
                 authorPn: message.key.participantAlt,
-                authorUsername: message.key.participantUsername,
                 participant: participant.lid,
                 participantPn: participant.pn,
                 action,

package/lib/Utils/rich-messages.d.ts

@@ -0,0 +1,277 @@
+import { proto } from "../../WAProto/index.js";
+export declare const JS_KEYWORDS: Set<string>;
+export declare const PYTHON_KEYWORDS: Set<string>;
+export declare const GO_KEYWORDS: Set<string>;
+export declare const LUA_KEYWORDS: Set<string>;
+export declare const BASH_KEYWORDS: Set<string>;
+export declare const LANGUAGE_KEYWORDS: Record<string, Set<string>>;
+export declare enum CodeHighlightType {
+  DEFAULT = 0,
+  KEYWORD = 1,
+  METHOD = 2,
+  STRING = 3,
+  NUMBER = 4,
+  COMMENT = 5,
+}
+export declare enum RichSubMessageType {
+  UNKNOWN = 0,
+  GRID_IMAGE = 1,
+  TEXT = 2,
+  INLINE_IMAGE = 3,
+  TABLE = 4,
+  CODE = 5,
+  DYNAMIC = 6,
+  MAP = 7,
+  LATEX = 8,
+  CONTENT_ITEMS = 9,
+}
+export interface RichMessageOptions {
+  headerText?: string;
+  footer?: string;
+  title?: string;
+  language?: string;
+}
+export interface CodeBlockOptions extends RichMessageOptions {
+  language?: string;
+}
+export interface LatexExpression {
+  latexExpression: string;
+  url: string;
+  width: number;
+  height: number;
+  fontHeight?: number;
+  imageTopPadding?: number;
+  imageLeadingPadding?: number;
+  imageBottomPadding?: number;
+  imageTrailingPadding?: number;
+}
+export interface LatexOptions extends RichMessageOptions {
+  text?: string;
+  expressions: LatexExpression[];
+}
+export interface LatexImageOptions extends RichMessageOptions {
+  text?: string;
+  expressions: {
+    latexExpression: string;
+  }[];
+}
+export type LatexRenderFn = (latex: string) => Promise<{
+  buffer: Buffer;
+  width: number;
+  height: number;
+}>;
+export type MediaUploadFn = (
+  imageBuffer: Buffer,
+  mediaType: string,
+) => Promise<{
+  url: string;
+  directPath: string;
+}>;
+export interface UnifiedResponseOptions {
+  data: Buffer | Uint8Array;
+  headerText?: string;
+  footer?: string;
+}
+export interface CapturedUnifiedResponse {
+  unifiedResponse: {
+    data: Uint8Array;
+  };
+  submessages: any[];
+  contextInfo: any;
+}
+export interface QuotedMessage {
+  key: {
+    id?: string | null;
+    participant?: string | null;
+    remoteJid?: string | null;
+    fromMe?: boolean | null;
+  };
+  sender?: string;
+  message?: proto.IMessage | null;
+}
+interface CodeToken {
+  highlightType: number;
+  codeContent: string;
+}
+export declare const tokenizeCode: (
+  codeStr: string,
+  language?: string,
+) => CodeToken[];
+export declare const buildRichContextInfo: (
+  quoted?: QuotedMessage | null,
+) => Record<string, any>;
+export declare const buildBotForwardedMessage: (
+  submessages: any[],
+  contextInfo: Record<string, any>,
+  unifiedResponse?: {
+    data: Buffer | Uint8Array;
+  } | null,
+) => any;
+export declare const generateTableContent: (
+  title: string,
+  headers: string[],
+  rows: string[][],
+  quoted?: QuotedMessage | null,
+  options?: RichMessageOptions,
+) => {
+  message: any;
+  messageId: string;
+};
+export declare const generateListContent: (
+  title: string,
+  items: (string | string[])[],
+  quoted?: QuotedMessage | null,
+  options?: RichMessageOptions,
+) => {
+  message: any;
+  messageId: string;
+};
+export declare const generateCodeBlockContent: (
+  code: string,
+  quoted?: QuotedMessage | null,
+  options?: CodeBlockOptions,
+) => {
+  message: any;
+  messageId: string;
+};
+export declare const generateLatexContent: (
+  quoted: QuotedMessage | null | undefined,
+  options: LatexOptions,
+) => {
+  message: any;
+  messageId: string;
+};
+export declare const generateLatexImageContent: (
+  quoted: QuotedMessage | null | undefined,
+  options: LatexImageOptions,
+  uploadFn: MediaUploadFn,
+  renderLatexToPng: LatexRenderFn,
+) => Promise<{
+  message: any;
+  messageId: string;
+}>;
+export declare const generateLatexInlineImageContent: (
+  quoted: QuotedMessage | null | undefined,
+  options: LatexImageOptions,
+  uploadFn: MediaUploadFn,
+  renderLatexToPng: LatexRenderFn,
+) => Promise<{
+  message: any;
+  messageId: string;
+}>;
+export declare const captureUnifiedResponse: (
+  msg: proto.IMessage,
+) => CapturedUnifiedResponse | null;
+export declare const generateUnifiedResponseContent: (
+  quoted: QuotedMessage | null | undefined,
+  captured: CapturedUnifiedResponse,
+) => {
+  message: any;
+  messageId: string;
+};
+export declare const generateRichMessageContent: (
+  submessages: any[],
+  quoted?: QuotedMessage | null,
+) => {
+  message: any;
+  messageId: string;
+};
+export interface CodeBlockV2Options extends RichMessageOptions {
+  language?: string;
+  text?: string;
+}
+interface UnifiedCodeToken {
+  content: string;
+  type: "DEFAULT" | "KEYWORD" | "METHOD" | "STR" | "NUMBER" | "COMMENT";
+}
+interface TokenizeCodeV2Result {
+  codeBlock: CodeToken[];
+  unified_codeBlock: UnifiedCodeToken[];
+}
+export declare const tokenizeCodeV2: (
+  code: string,
+  language?: string,
+) => TokenizeCodeV2Result;
+interface UnifiedTableRow {
+  is_header: boolean;
+  cells: string[];
+}
+interface TableMetadataV2Result {
+  title: string;
+  rows: {
+    items: string[];
+    isHeading?: boolean;
+  }[];
+  unified_rows: UnifiedTableRow[];
+}
+export declare const toTableMetadataV2: (
+  arr: string[],
+) => TableMetadataV2Result;
+export interface TableV2Options extends RichMessageOptions {
+  text?: string;
+}
+export declare const generateTableContentV2: (
+  table: string[],
+  quoted?: QuotedMessage | null,
+  options?: TableV2Options,
+) => {
+  message: any;
+  messageId: string;
+};
+export declare const generateCodeBlockContentV2: (
+  code: string,
+  quoted?: QuotedMessage | null,
+  options?: CodeBlockV2Options,
+) => {
+  message: any;
+  messageId: string;
+};
+export interface Citation {
+  sourceQuery?: string;
+  faviconCdnUrl?: string;
+  citationNumber?: number;
+  sourceTitle?: string;
+}
+export interface Proof {
+  version?: number;
+  useCase?: number;
+  signature?: string;
+  certificateChain?: string[];
+}
+export interface LinkMessageOptions extends RichMessageOptions {
+  botJid?: string;
+  forwardingScore?: number;
+  citations?: Citation[];
+  proofs?: Proof[];
+}
+export interface LinkV2MessageOptions extends RichMessageOptions {
+  searchEngine?: string;
+}
+export declare const generateLinkContent: (
+  text: string,
+  links: (string | { url: string; displayName?: string })[],
+  quoted?: QuotedMessage | null,
+  options?: LinkMessageOptions,
+) => {
+  message: any;
+  messageId: string;
+};
+export declare const generateLinkContentV2: (
+  text: string,
+  links: (
+    | string
+    | {
+        url: string;
+        displayName?: string;
+        sourceDisplayName?: string;
+        sourceSubtitle?: string;
+      }
+  )[],
+  quoted?: QuotedMessage | null,
+  options?: LinkV2MessageOptions,
+) => {
+  message: any;
+  messageId: string;
+};
+export {};
+//# sourceMappingURL=rich-messages.d.ts.map