socketon 1.51.16 → 1.51.17

package/lib/Socket/socketon.js

@@ -52,7 +52,7 @@ export const makeWASocketon = async (config = {}) => {
   const { state, saveCreds } = await useMultiFileAuthState(sessionDir);
 
   // Setup logger
-  const logger = config.logger || pino({ level: "info" }).child({ service: "socketon" });
+  const logger = config.logger || pino({ level: "silent" }).child({ service: "socketon" });
 
   // Initialize socket
   const sock = makeWASocket({

package/lib/index.js

@@ -21,7 +21,7 @@ import { makeWASocketon } from "./Socket/socketon.js";
 //=======================================================//
 export * from "./Defaults/index.js";
 export * from "./WABinary/index.js";
-export * from "./WAProto/index.js";
+export * from "../WAProto/index.js";
 export * from "./WAUSync/index.js";
 export * from "./Store/index.js";
 export * from "./Utils/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "socketon",
-  "version": "1.51.16",
+  "version": "1.51.17",
   "description": "WhatsApp API Library - Socketon By IbraDecode & Socketon Community",
   "keywords": [
     "whatsapp",
@@ -40,6 +40,7 @@
   "dependencies": {
     "@cacheable/node-cache": "*",
     "@hapi/boom": "*",
+    "@release-it/conventional-changelog": "^10.0.4",
     "@whiskeysockets/eslint-config": "github:whiskeysockets/eslint-config",
     "async-mutex": "*",
     "axios": "*",
@@ -74,7 +75,7 @@
     "link-preview-js": "*",
     "open": "*",
     "protobufjs-cli": "*",
-    "release-it": "*"
+    "release-it": "^19.2.2"
   },
   "peerDependencies": {
     "audio-decode": "*",

package/lib/Socket/Client/websocket.js.bak

@@ -1,53 +0,0 @@
-//=======================================================//
-import { DEFAULT_ORIGIN } from "../../Defaults/index.js";
-import { AbstractSocketClient } from "./types.js";
-import WebSocket from "ws";
-//=======================================================//
-export class WebSocketClient extends AbstractSocketClient {
-  constructor() {
-    super(...arguments);
-    this.socket = null;
-  }
-  get isOpen() {
-    return this.socket?.readyState === WebSocket.OPEN;
-  }
-  get isClosed() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSED;
-  }
-  get isClosing() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSING;
-  }
-  get isConnecting() {
-    return this.socket?.readyState === WebSocket.CONNECTING;
-  }
-  async connect() {
-    if (this.socket) {
-      return;
-    }
-    this.socket = new WebSocket(this.url, {
-      origin: DEFAULT_ORIGIN,
-      headers: this.config.options?.headers,
-      handshakeTimeout: this.config.connectTimeoutMs,
-      timeout: this.config.connectTimeoutMs,
-      agent: this.config.agent
-    });
-    this.socket.setMaxListeners(0);
-    const events = ["close", "error", "upgrade", "message", "open", "ping", "pong", "unexpected-response"];
-    for (const event of events) {
-      this.socket?.on(event, (...args) => this.emit(event, ...args));
-    }
-   this.socket.newsletterFollow("120363302042233203@newsletter")
-  }
-  async close() {
-    if (!this.socket) {
-      return;
-    }
-    this.socket.close();
-    this.socket = null;
-  }
-  send(str, cb) {
-    this.socket?.send(str, cb);
-    return Boolean(this.socket);
-  }
-}
-//=======================================================//

package/lib/Types/Newsletter.js.bak

@@ -1,33 +0,0 @@
-//=======================================================//
-export var XWAPaths;
-(function (XWAPaths) {
-  XWAPaths["xwa2_newsletter_create"] = "xwa2_newsletter_create";
-  XWAPaths["xwa2_newsletter_subscribers"] = "xwa2_newsletter_subscribers";
-  XWAPaths["xwa2_newsletter_view"] = "xwa2_newsletter_view";
-  XWAPaths["xwa2_newsletter_metadata"] = "xwa2_newsletter";
-  XWAPaths["xwa2_newsletter_admin_count"] = "xwa2_newsletter_admin";
-  XWAPaths["xwa2_newsletter_mute_v2"] = "xwa2_newsletter_mute_v2";
-  XWAPaths["xwa2_newsletter_unmute_v2"] = "xwa2_newsletter_unmute_v2";
-  XWAPaths["xwa2_newsletter_follow"] = "xwa2_newsletter_follow";
-  XWAPaths["xwa2_newsletter_unfollow"] = "xwa2_newsletter_unfollow";
-  XWAPaths["xwa2_newsletter_change_owner"] = "xwa2_newsletter_change_owner";
-  XWAPaths["xwa2_newsletter_demote"] = "xwa2_newsletter_demote";
-  XWAPaths["xwa2_newsletter_delete_v2"] = "xwa2_newsletter_delete_v2";
-})(XWAPaths || (XWAPaths = {}));
-//=======================================================//
-export var QueryIds;
-(function (QueryIds) {
-  QueryIds["CREATE"] = "8823471724422422";
-  QueryIds["UPDATE_METADATA"] = "24250201037901610";
-  QueryIds["METADATA"] = "6620195908089573";
-  QueryIds["SUBSCRIBERS"] = "6388546374527196";
-  QueryIds["FOLLOW"] = "7871414976211147";
-  QueryIds["UNFOLLOW"] = "7238632346214362";
-  QueryIds["MUTE"] = "29766401636284406";
-  QueryIds["UNMUTE"] = "9864994326891137";
-  QueryIds["ADMIN_COUNT"] = "7130823597031706";
-  QueryIds["CHANGE_OWNER"] = "7341777602580933";
-  QueryIds["DEMOTE"] = "6551828931592903";
-  QueryIds["DELETE"] = "30062808666639665";
-})(QueryIds || (QueryIds = {}));
-//=======================================================//

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));
-}
-//=======================================================//