@dappaoffc/baileys-mod 8.0.0 → 8.0.1

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

@@ -1,267 +0,0 @@
-//=======================================================//
-import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJidGroup, isJidMetaAI, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser } from "../WABinary/index.js";
-import { unpadRandomMax16 } from "./generics.js";
-import { proto } from "../../WAProto/index.js";
-import { Boom } from "@hapi/boom";
-//=======================================================//
-export const getDecryptionJid = async (sender, repository) => {
-  if (isLidUser(sender) || isHostedLidUser(sender)) {
-    return sender;
-  }
-  const mapped = await repository.lidMapping.getLIDForPN(sender);
-  return mapped || sender;
-};
-//=======================================================//
-const storeMappingFromEnvelope = async (stanza, sender, repository, decryptionJid, logger) => {
-  const { senderAlt } = extractAddressingContext(stanza);
-  if (senderAlt && isLidUser(senderAlt) && isPnUser(sender) && decryptionJid === sender) {
-    try {
-      await repository.lidMapping.storeLIDPNMappings([{ lid: senderAlt, pn: sender }]);
-      await repository.migrateSession(sender, senderAlt);
-      logger.debug({ sender, senderAlt }, "Stored LID mapping from envelope");
-    }
-    catch (error) {
-      logger.warn({ sender, senderAlt, error }, "Failed to store LID mapping");
-    }
-  }
-};
-//=======================================================//
-export const NO_MESSAGE_FOUND_ERROR_TEXT = "Message absent from node";
-export const MISSING_KEYS_ERROR_TEXT = "Key used already or never filled";
-//=======================================================//
-export const DECRYPTION_RETRY_CONFIG = {
-  maxRetries: 3,
-  baseDelayMs: 100,
-  sessionRecordErrors: ["No session record", "SessionError: No session record"]
-};
-//=======================================================//
-export const NACK_REASONS = {
-  ParsingError: 487,
-  UnrecognizedStanza: 488,
-  UnrecognizedStanzaClass: 489,
-  UnrecognizedStanzaType: 490,
-  InvalidProtobuf: 491,
-  InvalidHostedCompanionStanza: 493,
-  MissingMessageSecret: 495,
-  SignalErrorOldCounter: 496,
-  MessageDeletedOnPeer: 499,
-  UnhandledError: 500,
-  UnsupportedAdminRevoke: 550,
-  UnsupportedLIDGroup: 551,
-  DBOperationFailed: 552
-};
-//=======================================================//
-export const extractAddressingContext = (stanza) => {
-  let senderAlt;
-  let recipientAlt;
-  const sender = stanza.attrs.participant || stanza.attrs.from;
-  const addressingMode = stanza.attrs.addressing_mode || (sender?.endsWith("lid") ? "lid" : "pn");
-  if (addressingMode === "lid") {
-    senderAlt = stanza.attrs.participant_pn || stanza.attrs.sender_pn || stanza.attrs.peer_recipient_pn;
-    recipientAlt = stanza.attrs.recipient_pn;
-  }
-  else {
-    senderAlt = stanza.attrs.participant_lid || stanza.attrs.sender_lid || stanza.attrs.peer_recipient_lid;
-    recipientAlt = stanza.attrs.recipient_lid;
-  }
-  return {
-    addressingMode,
-    senderAlt,
-    recipientAlt
-  };
-};
-//=======================================================//
-export function decodeMessageNode(stanza, meId, meLid) {
-  let msgType;
-  let chatId;
-  let author;
-  let fromMe = false;
-  const msgId = stanza.attrs.id;
-  const from = stanza.attrs.from_pn;
-  const participant = stanza.attrs.participant_pn;
-  const recipient = stanza.attrs.recipient;
-  const addressingContext = extractAddressingContext(stanza);
-  const isMe = (jid) => areJidsSameUser(jid, meId);
-  const isMeLid = (jid) => areJidsSameUser(jid, meLid);
-  if (isPnUser(from) || isLidUser(from) || isHostedLidUser(from) || isHostedPnUser(from)) {
-    if (recipient && !isJidMetaAI(recipient)) {
-      if (!isMe(from) && !isMeLid(from)) {
-        throw new Boom("receipient present, but msg not from me", { data: stanza });
-      }
-      if (isMe(from) || isMeLid(from)) {
-        fromMe = true;
-      }
-      chatId = recipient;
-    }
-    else {
-      chatId = from;
-    }
-    msgType = "chat";
-    author = from;
-  }
-  else if (isJidGroup(from)) {
-    if (!participant) {
-      throw new Boom("No participant in group message");
-    }
-    if (isMe(participant) || isMeLid(participant)) {
-      fromMe = true;
-    }
-    msgType = "group";
-    author = participant;
-    chatId = from;
-  }
-  else if (isJidBroadcast(from)) {
-    if (!participant) {
-      throw new Boom("No participant in group message");
-    }
-    const isParticipantMe = isMe(participant);
-    if (isJidStatusBroadcast(from)) {
-      msgType = isParticipantMe ? "direct_peer_status" : "other_status";
-    }
-    else {
-      msgType = isParticipantMe ? "peer_broadcast" : "other_broadcast";
-    }
-    fromMe = isParticipantMe;
-    chatId = from;
-    author = participant;
-  }
-  else if (isJidNewsletter(from)) {
-    msgType = "newsletter";
-    chatId = from;
-    author = from;
-    if (isMe(from) || isMeLid(from)) {
-      fromMe = true;
-    }
-  }
-  else {
-    throw new Boom("Unknown message type", { data: stanza });
-  }
-  const pushname = stanza?.attrs?.notify;
-  const key = {
-    remoteJid: chatId,
-    remoteJidAlt: !isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
-    fromMe,
-    id: msgId,
-    participant,
-    participantAlt: isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
-    addressingMode: addressingContext.addressingMode,
-    ...(msgType === "newsletter" && stanza.attrs.server_id ? { server_id: stanza.attrs.server_id } : {})
-  };
-  const fullMessage = {
-    key,
-    messageTimestamp: +stanza.attrs.t,
-    pushName: pushname,
-    broadcast: isJidBroadcast(from)
-  };
-  if (key.fromMe) {
-    fullMessage.status = proto.WebMessageInfo.Status.SERVER_ACK;
-  }
-  return {
-    fullMessage,
-    author,
-    sender: msgType === "chat" ? author : chatId
-  };
-}
-//=======================================================//
-export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
-  const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid);
-  return {
-    fullMessage,
-    category: stanza.attrs.category,
-    author,
-    async decrypt() {
-      let decryptables = 0;
-      if (Array.isArray(stanza.content)) {
-        for (const { tag, attrs, content } of stanza.content) {
-          if (tag === "verified_name" && content instanceof Uint8Array) {
-            const cert = proto.VerifiedNameCertificate.decode(content);
-            const details = proto.VerifiedNameCertificate.Details.decode(cert.details);
-            fullMessage.verifiedBizName = details.verifiedName;
-          }
-          if (tag === "unavailable" && attrs.type === "view_once") {
-            fullMessage.key.isViewOnce = true;
-          }
-          if (tag !== "enc" && tag !== "plaintext") {
-            continue;
-          }
-          if (!(content instanceof Uint8Array)) {
-            continue;
-          }
-          decryptables += 1;
-          let msgBuffer;
-          const decryptionJid = await getDecryptionJid(author, repository);
-          if (tag !== "plaintext") {
-            await storeMappingFromEnvelope(stanza, author, repository, decryptionJid, logger);
-          }
-          try {
-            const e2eType = tag === "plaintext" ? "plaintext" : attrs.type;
-            switch (e2eType) {
-              case "skmsg":
-                msgBuffer = await repository.decryptGroupMessage({
-                  group: sender,
-                  authorJid: author,
-                  msg: content
-                });
-                break;
-              case "pkmsg":
-              case "msg":
-                msgBuffer = await repository.decryptMessage({
-                  jid: decryptionJid,
-                  type: e2eType,
-                  ciphertext: content
-                });
-                break;
-              case "plaintext":
-                msgBuffer = content;
-                break;
-              default:
-                throw new Error(`Unknown e2e type: ${e2eType}`);
-            }
-            let msg = proto.Message.decode(e2eType !== "plaintext" ? unpadRandomMax16(msgBuffer) : msgBuffer);
-            msg = msg.deviceSentMessage?.message || msg;
-            if (msg.senderKeyDistributionMessage) {
-              try {
-                await repository.processSenderKeyDistributionMessage({
-                  authorJid: author,
-                  item: msg.senderKeyDistributionMessage
-                });
-              }
-              catch (err) {
-                logger.error({ key: fullMessage.key, err }, "failed to process sender key distribution message");
-              }
-            }
-            if (fullMessage.message) {
-              Object.assign(fullMessage.message, msg);
-            }
-            else {
-              fullMessage.message = msg;
-            }
-          }
-          catch (err) {
-            const errorContext = {
-              key: fullMessage.key,
-              err,
-              messageType: tag === "plaintext" ? "plaintext" : attrs.type,
-              sender,
-              author,
-              isSessionRecordError: isSessionRecordError(err)
-            };
-            logger.error(errorContext, "failed to decrypt message");
-            fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
-            fullMessage.messageStubParameters = [err.message.toString()];
-          }
-        }
-      }
-      if (!decryptables) {
-        fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
-        fullMessage.messageStubParameters = [NO_MESSAGE_FOUND_ERROR_TEXT];
-      }
-    }
-  };
-};
-//=======================================================//
-function isSessionRecordError(error) {
-  const errorMessage = error?.message || error?.toString() || "";
-  return DECRYPTION_RETRY_CONFIG.sessionRecordErrors.some(errorPattern => errorMessage.includes(errorPattern));
-}
-//=======================================================//

package/lib/Utils/message-retry-manager.js

@@ -1,113 +0,0 @@
-//=======================================================//
-import { LRUCache } from "lru-cache";
-//=======================================================//
-const RECENT_MESSAGES_SIZE = 512;
-const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000;
-const PHONE_REQUEST_DELAY = 3000;
-export class MessageRetryManager {
-    constructor(logger, maxMsgRetryCount) {
-        this.logger = logger;
-        this.recentMessagesMap = new LRUCache({
-            max: RECENT_MESSAGES_SIZE
-        });
-        this.sessionRecreateHistory = new LRUCache({
-            ttl: RECREATE_SESSION_TIMEOUT * 2,
-            ttlAutopurge: true
-        });
-        this.retryCounters = new LRUCache({
-            ttl: 15 * 60 * 1000,
-            ttlAutopurge: true,
-            updateAgeOnGet: true
-        });
-        this.pendingPhoneRequests = {};
-        this.maxMsgRetryCount = 5;
-        this.statistics = {
-            totalRetries: 0,
-            successfulRetries: 0,
-            failedRetries: 0,
-            mediaRetries: 0,
-            sessionRecreations: 0,
-            phoneRequests: 0
-        };
-        this.maxMsgRetryCount = maxMsgRetryCount;
-    }
-    addRecentMessage(to, id, message) {
-        const key = { to, id };
-        const keyStr = this.keyToString(key);
-        this.recentMessagesMap.set(keyStr, {
-            message,
-            timestamp: Date.now()
-        });
-        this.logger.debug(`Added message to retry cache: ${to}/${id}`);
-    }
-    getRecentMessage(to, id) {
-        const key = { to, id };
-        const keyStr = this.keyToString(key);
-        return this.recentMessagesMap.get(keyStr);
-    }
-    shouldRecreateSession(jid, retryCount, hasSession) {
-        if (!hasSession) {
-            this.sessionRecreateHistory.set(jid, Date.now());
-            this.statistics.sessionRecreations++;
-            return {
-                reason: "we dont have a Signal session with them",
-                recreate: true
-            };
-        }
-        if (retryCount < 2) {
-            return { reason: "", recreate: false };
-        }
-        const now = Date.now();
-        const prevTime = this.sessionRecreateHistory.get(jid);
-        if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
-            this.sessionRecreateHistory.set(jid, now);
-            this.statistics.sessionRecreations++;
-            return {
-                reason: "retry count > 1 and over an hour since last recreation",
-                recreate: true
-            };
-        }
-        return { reason: "", recreate: false };
-    }
-    incrementRetryCount(messageId) {
-        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
-        this.statistics.totalRetries++;
-        return this.retryCounters.get(messageId);
-    }
-    getRetryCount(messageId) {
-        return this.retryCounters.get(messageId) || 0;
-    }
-    hasExceededMaxRetries(messageId) {
-        return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
-    }
-    markRetrySuccess(messageId) {
-        this.statistics.successfulRetries++;
-        this.retryCounters.delete(messageId);
-        this.cancelPendingPhoneRequest(messageId);
-    }
-    markRetryFailed(messageId) {
-        this.statistics.failedRetries++;
-        this.retryCounters.delete(messageId);
-    }
-    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
-        this.cancelPendingPhoneRequest(messageId);
-        this.pendingPhoneRequests[messageId] = setTimeout(() => {
-            delete this.pendingPhoneRequests[messageId];
-            this.statistics.phoneRequests++;
-            callback();
-        }, delay);
-        this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`);
-    }
-    cancelPendingPhoneRequest(messageId) {
-        const timeout = this.pendingPhoneRequests[messageId];
-        if (timeout) {
-            clearTimeout(timeout);
-            delete this.pendingPhoneRequests[messageId];
-            this.logger.debug(`Cancelled pending phone request for message ${messageId}`);
-        }
-    }
-    keyToString(key) {
-        return `${key.to}:${key.id}`;
-    }
-}
-//=======================================================//

package/lib/Utils/pre-key-manager.js

@@ -1,85 +0,0 @@
-//=======================================================//
-import PQueue from "p-queue";
-//=======================================================//
-export class PreKeyManager {
-  constructor(store, logger) {
-    this.store = store;
-    this.logger = logger;
-    this.queues = new Map();
-  }
-  getQueue(keyType) {
-    if (!this.queues.has(keyType)) {
-      this.queues.set(keyType, new PQueue({ concurrency: 1 }));
-    }
-    return this.queues.get(keyType);
-  }
-  async processOperations(data, keyType, transactionCache, mutations, isInTransaction) {
-    const keyData = data[keyType];
-    if (!keyData)
-      return;
-    return this.getQueue(keyType).add(async () => {
-      transactionCache[keyType] = transactionCache[keyType] || {};
-      mutations[keyType] = mutations[keyType] || {};
-      const deletions = [];
-      const updates = {};
-      for (const keyId in keyData) {
-        if (keyData[keyId] === null) {
-          deletions.push(keyId);
-        }
-        else {
-          updates[keyId] = keyData[keyId];
-        }
-      }
-      if (Object.keys(updates).length > 0) {
-        Object.assign(transactionCache[keyType], updates);
-        Object.assign(mutations[keyType], updates);
-      }
-      if (deletions.length > 0) {
-        await this.processDeletions(keyType, deletions, transactionCache, mutations, isInTransaction);
-      }
-    });
-  }
-  async processDeletions(keyType, ids, transactionCache, mutations, isInTransaction) {
-    if (isInTransaction) {
-      for (const keyId of ids) {
-        if (transactionCache[keyType]?.[keyId]) {
-          transactionCache[keyType][keyId] = null;
-          mutations[keyType][keyId] = null;
-        }
-        else {
-          this.logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`);
-        }
-      }
-    }
-    else {
-      const existingKeys = await this.store.get(keyType, ids);
-      for (const keyId of ids) {
-        if (existingKeys[keyId]) {
-          transactionCache[keyType][keyId] = null;
-          mutations[keyType][keyId] = null;
-        }
-        else {
-          this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
-        }
-      }
-    }
-  }
-  async validateDeletions(data, keyType) {
-    const keyData = data[keyType];
-    if (!keyData)
-      return;
-    return this.getQueue(keyType).add(async () => {
-      const deletionIds = Object.keys(keyData).filter(id => keyData[id] === null);
-      if (deletionIds.length === 0)
-        return;
-      const existingKeys = await this.store.get(keyType, deletionIds);
-      for (const keyId of deletionIds) {
-        if (!existingKeys[keyId]) {
-          this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
-          delete data[keyType][keyId];
-        }
-      }
-    });
-  }
-}
-//=======================================================//