@skyzopedia/baileys-mod 3.0.2

package/lib/Socket/messages-send.js

@@ -0,0 +1,1082 @@
+//=======================================================//
+import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from "../Utils/index.js";
+import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidGroup, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from "../WABinary/index.js";
+import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from "../Defaults/index.js";
+import { USyncQuery, USyncUser } from "../WAUSync/index.js";
+import { makeKeyedMutex } from "../Utils/make-mutex.js";
+import { makeNewsletterSocket } from "./newsletter.js";
+import { getUrlInfo } from "../Utils/link-preview.js";
+import { proto } from "../../WAProto/index.js";
+import NodeCache from "@cacheable/node-cache";
+import { Boom } from "@hapi/boom";
+import crypto from "crypto";
+//=======================================================//
+export const makeMessagesSocket = (config) => {
+  const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
+  const sock = makeNewsletterSocket(config);
+  const { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
+  const userDevicesCache = config.userDevicesCache ||
+    new NodeCache({
+      stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
+      useClones: false
+    });
+  const peerSessionsCache = new NodeCache({
+    stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
+    useClones: false
+  });
+  const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;
+  const encryptionMutex = makeKeyedMutex();
+  let mediaConn;
+  const refreshMediaConn = async (forceGet = false) => {
+    const media = await mediaConn;
+    if (!media || forceGet || new Date().getTime() - media.fetchDate.getTime() > media.ttl * 1000) {
+      mediaConn = (async () => {
+        const result = await query({
+          tag: "iq",
+          attrs: {
+            type: "set",
+            xmlns: "w:m",
+            to: S_WHATSAPP_NET
+          },
+          content: [{ tag: "media_conn", attrs: {} }]
+        });
+        const mediaConnNode = getBinaryNodeChild(result, "media_conn");
+        const node = {
+          hosts: getBinaryNodeChildren(mediaConnNode, "host").map(({ attrs }) => ({
+            hostname: attrs.hostname,
+            maxContentLengthBytes: +attrs.maxContentLengthBytes
+          })),
+          auth: mediaConnNode.attrs.auth,
+          ttl: +mediaConnNode.attrs.ttl,
+          fetchDate: new Date()
+        };
+        logger.debug("fetched media conn");
+        return node;
+      })();
+    }
+    return mediaConn;
+  };
+  const sendReceipt = async (jid, participant, messageIds, type) => {
+    if (!messageIds || messageIds.length === 0) {
+      throw new Boom("missing ids in receipt");
+    }
+    const node = {
+      tag: "receipt",
+      attrs: {
+        id: messageIds[0]
+      }
+    };
+    const isReadReceipt = type === "read" || type === "read-self";
+    if (isReadReceipt) {
+      node.attrs.t = unixTimestampSeconds().toString();
+    }
+    if (type === "sender" && (isPnUser(jid) || isLidUser(jid))) {
+      node.attrs.recipient = jid;
+      node.attrs.to = participant;
+    }
+    else {
+      node.attrs.to = jid;
+      if (participant) {
+        node.attrs.participant = participant;
+      }
+    }
+    if (type) {
+      node.attrs.type = type;
+    }
+    const remainingMessageIds = messageIds.slice(1);
+    if (remainingMessageIds.length) {
+      node.content = [
+        {
+          tag: "list",
+          attrs: {},
+          content: remainingMessageIds.map(id => ({
+            tag: "item",
+            attrs: { id }
+          }))
+        }
+      ];
+    }
+    logger.debug({ attrs: node.attrs, messageIds }, "sending receipt for messages");
+    await sendNode(node);
+  };
+  const sendReceipts = async (keys, type) => {
+    const recps = aggregateMessageKeysNotFromMe(keys);
+    for (const { jid, participant, messageIds } of recps) {
+      await sendReceipt(jid, participant, messageIds, type);
+    }
+  };
+  const readMessages = async (keys) => {
+    const privacySettings = await fetchPrivacySettings();
+    const readType = privacySettings.readreceipts === "all" ? "read" : "read-self";
+    await sendReceipts(keys, readType);
+  };
+  const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
+    const deviceResults = [];
+    if (!useCache) {
+      logger.debug("not using cache for devices");
+    }
+    const toFetch = [];
+    const jidsWithUser = jids
+      .map(jid => {
+      const decoded = jidDecode(jid);
+      const user = decoded?.user;
+      const device = decoded?.device;
+      const isExplicitDevice = typeof device === "number" && device >= 0;
+      if (isExplicitDevice && user) {
+        deviceResults.push({
+          user,
+          device,
+          jid
+        });
+        return null;
+      }
+      jid = jidNormalizedUser(jid);
+      return { jid, user };
+    })
+      .filter(jid => jid !== null);
+    let mgetDevices;
+    if (useCache && userDevicesCache.mget) {
+      const usersToFetch = jidsWithUser.map(j => j?.user).filter(Boolean);
+      mgetDevices = await userDevicesCache.mget(usersToFetch);
+    }
+    for (const { jid, user } of jidsWithUser) {
+      if (useCache) {
+        const devices = mgetDevices?.[user] ||
+          (userDevicesCache.mget ? undefined : (await userDevicesCache.get(user)));
+        if (devices) {
+          const devicesWithJid = devices.map(d => ({
+            ...d,
+            jid: jidEncode(d.user, d.server, d.device)
+          }));
+          deviceResults.push(...devicesWithJid);
+          logger.trace({ user }, "using cache for devices");
+        }
+        else {
+          toFetch.push(jid);
+        }
+      }
+      else {
+        toFetch.push(jid);
+      }
+    }
+    if (!toFetch.length) {
+      return deviceResults;
+    }
+    const requestedLidUsers = new Set();
+    for (const jid of toFetch) {
+      if (isLidUser(jid) || isHostedLidUser(jid)) {
+        const user = jidDecode(jid)?.user;
+        if (user)
+          requestedLidUsers.add(user);
+      }
+    }
+    const query = new USyncQuery().withContext("message").withDeviceProtocol().withLIDProtocol();
+    for (const jid of toFetch) {
+      query.withUser(new USyncUser().withId(jid));
+    }
+    const result = await sock.executeUSyncQuery(query);
+    if (result) {
+      const lidResults = result.list.filter(a => !!a.lid);
+      if (lidResults.length > 0) {
+        logger.trace("Storing LID maps from device call");
+        await signalRepository.lidMapping.storeLIDPNMappings(lidResults.map(a => ({ lid: a.lid, pn: a.id })));
+      }
+      const extracted = extractDeviceJids(result?.list, authState.creds.me.id, authState.creds.me.lid, ignoreZeroDevices);
+      const deviceMap = {};
+      for (const item of extracted) {
+        deviceMap[item.user] = deviceMap[item.user] || [];
+        deviceMap[item.user]?.push(item);
+      }
+      for (const [user, userDevices] of Object.entries(deviceMap)) {
+        const isLidUser = requestedLidUsers.has(user);
+        for (const item of userDevices) {
+          const finalJid = isLidUser
+            ? jidEncode(user, item.server, item.device)
+            : jidEncode(item.user, item.server, item.device);
+          deviceResults.push({
+            ...item,
+            jid: finalJid
+          });
+          logger.debug({
+            user: item.user,
+            device: item.device,
+            finalJid,
+            usedLid: isLidUser
+          }, "Processed device with LID priority");
+        }
+      }
+      if (userDevicesCache.mset) {
+        await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })));
+      }
+      else {
+        for (const key in deviceMap) {
+          if (deviceMap[key])
+            await userDevicesCache.set(key, deviceMap[key]);
+        }
+      }
+      const userDeviceUpdates = {};
+      for (const [userId, devices] of Object.entries(deviceMap)) {
+        if (devices && devices.length > 0) {
+          userDeviceUpdates[userId] = devices.map(d => d.device?.toString() || "0");
+        }
+      }
+      if (Object.keys(userDeviceUpdates).length > 0) {
+        try {
+          await authState.keys.set({ "device-list": userDeviceUpdates });
+          logger.debug({ userCount: Object.keys(userDeviceUpdates).length }, "stored user device lists for bulk migration");
+        }
+        catch (error) {
+          logger.warn({ error }, "failed to store user device lists");
+        }
+      }
+    }
+    return deviceResults;
+  };
+  const assertSessions = async (jids) => {
+    let didFetchNewSession = false;
+    const uniqueJids = [...new Set(jids)];
+    const jidsRequiringFetch = [];
+    logger.debug({ jids }, "assertSessions call with jids");
+    for (const jid of uniqueJids) {
+      const signalId = signalRepository.jidToSignalProtocolAddress(jid);
+      const cachedSession = peerSessionsCache.get(signalId);
+      if (cachedSession !== undefined) {
+        if (cachedSession) {
+          continue;
+        }
+      }
+      else {
+        const sessionValidation = await signalRepository.validateSession(jid);
+        const hasSession = sessionValidation.exists;
+        peerSessionsCache.set(signalId, hasSession);
+        if (hasSession) {
+          continue;
+        }
+      }
+      jidsRequiringFetch.push(jid);
+    }
+    if (jidsRequiringFetch.length) {
+      const wireJids = [
+        ...jidsRequiringFetch.filter(jid => !!isLidUser(jid) || !!isHostedLidUser(jid)),
+        ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!isPnUser(jid) || !!isHostedPnUser(jid)))) || []).map(a => a.lid)
+      ];
+      logger.debug({ jidsRequiringFetch, wireJids }, "fetching sessions");
+      const result = await query({
+        tag: "iq",
+        attrs: {
+          xmlns: "encrypt",
+          type: "get",
+          to: S_WHATSAPP_NET
+        },
+        content: [
+          {
+            tag: "key",
+            attrs: {},
+            content: wireJids.map(jid => ({
+              tag: "user",
+              attrs: { jid }
+            }))
+          }
+        ]
+      });
+      await parseAndInjectE2ESessions(result, signalRepository);
+      didFetchNewSession = true;
+      for (const wireJid of wireJids) {
+        const signalId = signalRepository.jidToSignalProtocolAddress(wireJid);
+        peerSessionsCache.set(signalId, true);
+      }
+    }
+    return didFetchNewSession;
+  };
+  const sendPeerDataOperationMessage = async (pdoMessage) => {
+    if (!authState.creds.me?.id) {
+      throw new Boom("Not authenticated");
+    }
+    const protocolMessage = {
+      protocolMessage: {
+        peerDataOperationRequestMessage: pdoMessage,
+        type: proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE
+      }
+    };
+    const meJid = jidNormalizedUser(authState.creds.me.id);
+    const msgId = await relayMessage(meJid, protocolMessage, {
+      additionalAttributes: {
+        category: "peer",
+        push_priority: "high_force"
+      },
+      additionalNodes: [
+        {
+          tag: "meta",
+          attrs: { appdata: "default" }
+        }
+      ]
+    });
+    return msgId;
+  };
+  const offerCall = async (toJid, isVideo = false) => {
+    const callId = crypto
+      .randomBytes(16)
+      .toString("hex")
+      .toUpperCase()
+      .substring(0, 64);
+    const offerContent = [];
+    offerContent.push({
+      tag: "audio",
+      attrs: { enc: "opus", rate: "16000" },
+      content: undefined,
+    });
+    offerContent.push({
+      tag: "audio",
+      attrs: { enc: "opus", rate: "8000" },
+      content: undefined,
+    });
+    if (isVideo) {
+      offerContent.push({
+        tag: "video",
+        attrs: {
+          enc: "vp8",
+          dec: "vp8",
+          orientation: "0",
+          screen_width: "1920",
+          screen_height: "1080",
+          device_orientation: "0",
+        },
+        content: undefined,
+      });
+    }
+    offerContent.push({
+      tag: "net",
+      attrs: { medium: "3" },
+      content: undefined,
+    });
+    offerContent.push({
+      tag: "capability",
+      attrs: { ver: "1" },
+      content: new Uint8Array([1, 4, 255, 131, 207, 4]),
+    });
+    offerContent.push({
+      tag: "encopt",
+      attrs: { keygen: "2" },
+      content: undefined,
+    });
+    const encKey = crypto.randomBytes(32);
+    const rawDevices = await getUSyncDevices([toJid], true, false);
+    const devices = rawDevices.map(({ user, device }) =>
+      jidEncode(user, "s.whatsapp.net", device)
+    );
+    await assertSessions(devices, true);
+    const { nodes: destinations, shouldIncludeDeviceIdentity } =
+      await createParticipantNodes(
+        devices,
+        { call: { callKey: new Uint8Array(encKey) } },
+        { count: "0" }
+      );
+    offerContent.push({ tag: "destination", attrs: {}, content: destinations });
+    if (shouldIncludeDeviceIdentity) {
+      offerContent.push({
+        tag: "device-identity",
+        attrs: {},
+        content: encodeSignedDeviceIdentity(
+          authState.creds.account,
+          true
+        ),
+      });
+    }
+    const stanza = {
+      tag: "call",
+      attrs: {
+        id: generateMessageIDV2(),
+        to: toJid,
+      },
+      content: [
+        {
+          tag: "offer",
+          attrs: {
+            "call-id": callId,
+            "call-creator": authState.creds.me.id,
+          },
+          content: offerContent,
+        },
+      ],
+    };
+    await query(stanza);
+    return {
+      id: callId,
+      to: toJid,
+    };
+  };
+  const createParticipantNodes = async (recipientJids, message, extraAttrs, dsmMessage) => {
+    if (!recipientJids.length) {
+      return { nodes: [], shouldIncludeDeviceIdentity: false };
+    }
+    const patched = await patchMessageBeforeSending(message, recipientJids);
+    const patchedMessages = Array.isArray(patched)
+      ? patched
+      : recipientJids.map(jid => ({ recipientJid: jid, message: patched }));
+    let shouldIncludeDeviceIdentity = false;
+    const meId = authState.creds.me.id;
+    const meLid = authState.creds.me?.lid;
+    const meLidUser = meLid ? jidDecode(meLid)?.user : null;
+    const encryptionPromises = patchedMessages.map(async ({ recipientJid: jid, message: patchedMessage }) => {
+      if (!jid)
+        return null;
+      let msgToEncrypt = patchedMessage;
+      if (dsmMessage) {
+        const { user: targetUser } = jidDecode(jid);
+        const { user: ownPnUser } = jidDecode(meId);
+        const ownLidUser = meLidUser;
+        const isOwnUser = targetUser === ownPnUser || (ownLidUser && targetUser === ownLidUser);
+        const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+        if (isOwnUser && !isExactSenderDevice) {
+          msgToEncrypt = dsmMessage;
+          logger.debug({ jid, targetUser }, "Using DSM for own device");
+        }
+      }
+      const bytes = encodeWAMessage(msgToEncrypt);
+      const mutexKey = jid;
+      const node = await encryptionMutex.mutex(mutexKey, async () => {
+        const { type, ciphertext } = await signalRepository.encryptMessage({
+          jid,
+          data: bytes
+        });
+        if (type === "pkmsg") {
+          shouldIncludeDeviceIdentity = true;
+        }
+        return {
+          tag: "to",
+          attrs: { jid },
+          content: [
+            {
+              tag: "enc",
+              attrs: {
+                v: "2",
+                type,
+                ...(extraAttrs || {})
+              },
+              content: ciphertext
+            }
+          ]
+        };
+      });
+      return node;
+    });
+    const nodes = (await Promise.all(encryptionPromises)).filter(node => node !== null);
+    return { nodes, shouldIncludeDeviceIdentity };
+  };
+  const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }) => {
+    const meId = authState.creds.me.id;
+    const meLid = authState.creds.me?.lid;
+    const isRetryResend = Boolean(participant?.jid);
+    let shouldIncludeDeviceIdentity = isRetryResend;
+    const statusJid = "status@broadcast";
+    const { user, server } = jidDecode(jid);
+    const isGroup = server === "g.us";
+    const isStatus = jid === statusJid;
+    const isLid = server === "lid";
+    const isNewsletter = server === "newsletter";
+    const finalJid = jid;
+    msgId = msgId || generateMessageIDV2(meId);
+    useUserDevicesCache = useUserDevicesCache !== false;
+    useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus;
+    const participants = [];
+    const destinationJid = !isStatus ? finalJid : statusJid;
+    const binaryNodeContent = [];
+    const devices = [];
+    const meMsg = {
+      deviceSentMessage: {
+        destinationJid,
+        message
+      },
+      messageContextInfo: message.messageContextInfo
+    };
+    const extraAttrs = {};
+    if (participant) {
+      if (!isGroup && !isStatus) {
+        additionalAttributes = { ...additionalAttributes, device_fanout: "false" };
+      }
+      const { user, device } = jidDecode(participant.jid);
+      devices.push({
+        user,
+        device,
+        jid: participant.jid
+      });
+    }
+    await authState.keys.transaction(async () => {
+      const mediaType = getMediaType(message);
+      if (mediaType) {
+        extraAttrs["mediatype"] = mediaType;
+      }
+      if (isNewsletter) {
+        const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
+        const bytes = encodeNewsletterMessage(patched);
+        binaryNodeContent.push({
+          tag: "plaintext",
+          attrs: {},
+          content: bytes
+        });
+        const stanza = {
+          tag: "message",
+          attrs: {
+            to: jid,
+            id: msgId,
+            type: getMessageType(message),
+            ...(additionalAttributes || {})
+          },
+          content: binaryNodeContent
+        };
+        logger.debug({ msgId }, `sending newsletter message to ${jid}`);
+        await sendNode(stanza);
+        return;
+      }
+      if (normalizeMessageContent(message)?.pinInChatMessage) {
+        extraAttrs["decrypt-fail"] = "hide";
+      }
+      if (isGroup || isStatus) {
+        const [groupData, senderKeyMap] = await Promise.all([
+          (async () => {
+            let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined;
+            if (groupData && Array.isArray(groupData?.participants)) {
+              logger.trace({ jid, participants: groupData.participants.length }, "using cached group metadata");
+            }
+            else if (!isStatus) {
+              groupData = await groupMetadata(jid);
+            }
+            return groupData;
+          })(),
+          (async () => {
+            if (!participant && !isStatus) {
+              const result = await authState.keys.get("sender-key-memory", [jid]);
+              return result[jid] || {};
+            }
+            return {};
+          })()
+        ]);
+        if (!participant) {
+          const participantsList = [];
+          if (isStatus) {
+            if (statusJidList?.length)
+              participantsList.push(...statusJidList);
+          }
+          else {
+            let groupAddressingMode = "lid";
+            if (groupData) {
+              participantsList.push(...groupData.participants.map(p => p.id));
+              groupAddressingMode = groupData?.addressingMode || groupAddressingMode;
+            }
+            additionalAttributes = {
+              ...additionalAttributes,
+              addressing_mode: groupAddressingMode
+            };
+          }
+          const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false);
+          devices.push(...additionalDevices);
+        }
+        if (groupData?.ephemeralDuration && groupData.ephemeralDuration > 0) {
+          additionalAttributes = {
+            ...additionalAttributes,
+            expiration: groupData.ephemeralDuration.toString()
+          };
+        }
+        const patched = await patchMessageBeforeSending(message);
+        if (Array.isArray(patched)) {
+          throw new Boom("Per-jid patching is not supported in groups");
+        }
+        const bytes = encodeWAMessage(patched);
+        const groupAddressingMode = additionalAttributes?.["addressing_mode"] || groupData?.addressingMode || "lid";
+        const groupSenderIdentity = groupAddressingMode === "lid" && meLid ? meLid : meId;
+        const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({
+          group: destinationJid,
+          data: bytes,
+          meId: groupSenderIdentity
+        });
+        const senderKeyRecipients = [];
+        for (const device of devices) {
+          const deviceJid = device.jid;
+          const hasKey = !!senderKeyMap[deviceJid];
+          if ((!hasKey || !!participant) &&
+            !isHostedLidUser(deviceJid) &&
+            !isHostedPnUser(deviceJid) &&
+            device.device !== 99) {
+            senderKeyRecipients.push(deviceJid);
+            senderKeyMap[deviceJid] = true;
+          }
+        }
+        if (senderKeyRecipients.length) {
+          logger.debug({ senderKeyJids: senderKeyRecipients }, "sending new sender key");
+          const senderKeyMsg = {
+            senderKeyDistributionMessage: {
+              axolotlSenderKeyDistributionMessage: senderKeyDistributionMessage,
+              groupId: destinationJid
+            }
+          };
+          const senderKeySessionTargets = senderKeyRecipients;
+          await assertSessions(senderKeySessionTargets);
+          const result = await createParticipantNodes(senderKeyRecipients, senderKeyMsg, extraAttrs);
+          shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || result.shouldIncludeDeviceIdentity;
+          participants.push(...result.nodes);
+        }
+        if (isRetryResend) {
+          const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
+            data: bytes,
+            jid: participant?.jid
+          });
+          binaryNodeContent.push({
+            tag: "enc",
+            attrs: {
+              v: "2",
+              type,
+              count: participant.count.toString()
+            },
+            content: encryptedContent
+          });
+        }
+        else {
+          binaryNodeContent.push({
+            tag: "enc",
+            attrs: { v: "2", type: "skmsg", ...extraAttrs },
+            content: ciphertext
+          });
+          await authState.keys.set({ "sender-key-memory": { [jid]: senderKeyMap } });
+        }
+      }
+      else {
+        let ownId = meId;
+        if (isLid && meLid) {
+          ownId = meLid;
+          logger.debug({ to: jid, ownId }, "Using LID identity for @lid conversation");
+        }
+        else {
+          logger.debug({ to: jid, ownId }, "Using PN identity for @s.whatsapp.net conversation");
+        }
+        const { user: ownUser } = jidDecode(ownId);
+        if (!participant) {
+          const targetUserServer = isLid ? "lid" : "s.whatsapp.net";
+          devices.push({
+            user,
+            device: 0,
+            jid: jidEncode(user, targetUserServer, 0)
+          });
+          if (user !== ownUser) {
+            const ownUserServer = isLid ? "lid" : "s.whatsapp.net";
+            const ownUserForAddressing = isLid && meLid ? jidDecode(meLid).user : jidDecode(meId).user;
+            devices.push({
+              user: ownUserForAddressing,
+              device: 0,
+              jid: jidEncode(ownUserForAddressing, ownUserServer, 0)
+            });
+          }
+          if (additionalAttributes?.["category"] !== "peer") {
+            devices.length = 0;
+            const senderIdentity = isLid && meLid
+              ? jidEncode(jidDecode(meLid)?.user, "lid", undefined)
+              : jidEncode(jidDecode(meId)?.user, "s.whatsapp.net", undefined);
+            const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false);
+            devices.push(...sessionDevices);
+            logger.debug({
+              deviceCount: devices.length,
+              devices: devices.map(d => `${d.user}:${d.device}@${jidDecode(d.jid)?.server}`)
+            }, "Device enumeration complete with unified addressing");
+          }
+        }
+        const allRecipients = [];
+        const meRecipients = [];
+        const otherRecipients = [];
+        const { user: mePnUser } = jidDecode(meId);
+        const { user: meLidUser } = meLid ? jidDecode(meLid) : { user: null };
+        for (const { user, jid } of devices) {
+          const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+          if (isExactSenderDevice) {
+            logger.debug({ jid, meId, meLid }, "Skipping exact sender device (whatsmeow pattern)");
+            continue;
+          }
+          const isMe = user === mePnUser || user === meLidUser;
+          if (isMe) {
+            meRecipients.push(jid);
+          }
+          else {
+            otherRecipients.push(jid);
+          }
+          allRecipients.push(jid);
+        }
+        await assertSessions(allRecipients);
+        const [{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 }, { nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }] = await Promise.all([
+          createParticipantNodes(meRecipients, meMsg || message, extraAttrs),
+          createParticipantNodes(otherRecipients, message, extraAttrs, meMsg)
+        ]);
+        participants.push(...meNodes);
+        participants.push(...otherNodes);
+        if (meRecipients.length > 0 || otherRecipients.length > 0) {
+          extraAttrs["phash"] = generateParticipantHashV2([...meRecipients, ...otherRecipients]);
+        }
+        shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2;
+      }
+      if (participants.length) {
+        if (additionalAttributes?.["category"] === "peer") {
+          const peerNode = participants[0]?.content?.[0];
+          if (peerNode) {
+            binaryNodeContent.push(peerNode);
+          }
+        }
+        else {
+          binaryNodeContent.push({
+            tag: "participants",
+            attrs: {},
+            content: participants
+          });
+        }
+      }
+      const stanza = {
+        tag: "message",
+        attrs: {
+          id: msgId,
+          to: destinationJid,
+          type: getMessageType(message),
+          ...(additionalAttributes || {})
+        },
+        content: binaryNodeContent
+      };
+     if (participant) {
+       if (isJidGroup(destinationJid)) {
+         stanza.attrs.to = destinationJid;
+         stanza.attrs.participant = participant.lid;
+       }
+       else if (areJidsSameUser(participant.lid, meId)) {
+         stanza.attrs.to = participant.lid;
+         stanza.attrs.recipient = destinationJid;
+       }
+       else {
+         stanza.attrs.to = participant.lid;
+       }
+     }
+     else {
+       stanza.attrs.to = destinationJid;
+     }
+     
+     if (shouldIncludeDeviceIdentity) {
+       stanza.content.push({
+         tag: "device-identity",
+         attrs: {},
+         content: encodeSignedDeviceIdentity(authState.creds.account, true)
+       });
+       logger.debug({ destinationJid }, "adding device identity");
+     }
+     
+     if (additionalNodes && additionalNodes.length > 0) {
+       stanza.content.push(...additionalNodes);
+     }
+     else {
+       if ((isJidGroup(destinationJid) || isLidUser(destinationJid)) &&
+         (message?.viewOnceMessage ? message?.viewOnceMessage :
+           (message?.viewOnceMessageV2 ? message?.viewOnceMessageV2 :
+             (message?.viewOnceMessageV2Extension ? message?.viewOnceMessageV2Extension :
+               (message?.ephemeralMessage ? message?.ephemeralMessage :
+                 (message?.templateMessage ? message?.templateMessage :
+                   (message?.interactiveMessage ? message?.interactiveMessage :
+                     message?.buttonsMessage))))))) {
+         stanza.content.push({
+           tag: "biz",
+           attrs: {},
+           content: [{
+             tag: "interactive",
+             attrs: {
+               type: "native_flow",
+               v: "1"
+             },
+             content: [{
+               tag: "native_flow",
+               attrs: { name: "quick_reply" }
+             }]
+           }]
+         });
+       }
+     }
+      const buttonType = getButtonType(message);
+      if (buttonType) {
+        stanza.content.push({
+          tag: "biz",
+          attrs: {},
+          content: [
+            {
+              tag: buttonType,
+              attrs: getButtonArgs(message),
+            }
+          ]
+        });
+        logger.debug({ jid }, "adding business node");
+      }
+
+      logger.debug({ msgId }, `sending message to ${participants.length} devices`);
+      await sendNode(stanza);
+    });
+    return msgId;
+  };
+  const getMessageType = (message) => {
+    if (message.pollCreationMessage || message.pollCreationMessageV2 || message.pollCreationMessageV3) {
+      return "poll";
+    }
+    if (message.eventMessage) {
+      return "event";
+    }
+    if (getMediaType(message) !== "") {
+      return "media";
+    }
+    return "text";
+  };
+  const getMediaType = (message) => {
+    if (message.imageMessage) {
+      return "image";
+    }
+    else if (message.videoMessage) {
+      return message.videoMessage.gifPlayback ? "gif" : "video";
+    }
+    else if (message.audioMessage) {
+      return message.audioMessage.ptt ? "ptt" : "audio";
+    }
+    else if (message.contactMessage) {
+      return "vcard";
+    }
+    else if (message.documentMessage) {
+      return "document";
+    }
+    else if (message.contactsArrayMessage) {
+      return "contact_array";
+    }
+    else if (message.liveLocationMessage) {
+      return "livelocation";
+    }
+    else if (message.stickerMessage) {
+      return "sticker";
+    }
+    else if (message.listMessage) {
+      return "list";
+    }
+    else if (message.listResponseMessage) {
+      return "list_response";
+    }
+    else if (message.buttonsResponseMessage) {
+      return "buttons_response";
+    }
+    else if (message.orderMessage) {
+      return "order";
+    }
+    else if (message.productMessage) {
+      return "product";
+    }
+    else if (message.interactiveResponseMessage) {
+      return "native_flow_response";
+    }
+    else if (message.groupInviteMessage) {
+      return "url";
+    }
+    return "";
+  };
+  const getButtonType = (message) => {
+    if (message.buttonsMessage) {
+      return "buttons";
+    }
+    else if (message.buttonsResponseMessage) {
+      return "buttons_response";
+    }
+    else if (message.interactiveResponseMessage) {
+      return "interactive_response";
+    }
+    else if (message.listMessage) {
+      return "list";
+    }
+    else if (message.listResponseMessage) {
+      return "list_response";
+    }
+  };
+  const getButtonArgs = (message) => {
+    if (message.templateMessage) {
+      return {};
+    }
+    else if (message.listMessage) {
+      const type = message.listMessage.listType;
+      if (!type) {
+        throw new Boom("Expected list type inside message");
+      }
+      return { v: "2", type: proto.ListMessage.ListType[type].toLowerCase() };
+    }
+    else {
+      return {};
+    }
+  };
+  const getPrivacyTokens = async (jids) => {
+    const t = unixTimestampSeconds().toString();
+    const result = await query({
+      tag: "iq",
+      attrs: {
+        to: S_WHATSAPP_NET,
+        type: "set",
+        xmlns: "privacy"
+      },
+      content: [
+        {
+          tag: "tokens",
+          attrs: {},
+          content: jids.map(jid => ({
+            tag: "token",
+            attrs: {
+              jid: jidNormalizedUser(jid),
+              t,
+              type: "trusted_contact"
+            }
+          }))
+        }
+      ]
+    });
+    return result;
+  };
+  const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
+  const waitForMsgMediaUpdate = bindWaitForEvent(ev, "messages.media-update");
+  return {
+    ...sock,
+    offerCall,
+    getButtonType,
+    getButtonArgs,
+    getPrivacyTokens,
+    assertSessions,
+    relayMessage,
+    sendReceipt,
+    sendReceipts,
+    readMessages,
+    refreshMediaConn,
+    waUploadToServer,
+    fetchPrivacySettings,
+    sendPeerDataOperationMessage,
+    createParticipantNodes,
+    getUSyncDevices,
+    messageRetryManager,
+    updateMediaMessage: async (message) => {
+      const content = assertMediaContent(message.message);
+      const mediaKey = content.mediaKey;
+      const meId = authState.creds.me.id;
+      const node = await encryptMediaRetryRequest(message.key, mediaKey, meId);
+      let error = undefined;
+      await Promise.all([
+        sendNode(node),
+        waitForMsgMediaUpdate(async (update) => {
+          const result = update.find(c => c.key.id === message.key.id);
+          if (result) {
+            if (result.error) {
+              error = result.error;
+            }
+            else {
+              try {
+                const media = await decryptMediaRetryData(result.media, mediaKey, result.key.id);
+                if (media.result !== proto.MediaRetryNotification.ResultType.SUCCESS) {
+                  const resultStr = proto.MediaRetryNotification.ResultType[media.result];
+                  throw new Boom(`Media re-upload failed by device (${resultStr})`, {
+                    data: media,
+                    statusCode: getStatusCodeForMediaRetry(media.result) || 404
+                  });
+                }
+                content.directPath = media.directPath;
+                content.url = getUrlFromDirectPath(content.directPath);
+                logger.debug({ directPath: media.directPath, key: result.key }, "media update successful");
+              }
+              catch (err) {
+                error = err;
+              }
+            }
+            return true;
+          }
+        })
+      ]);
+      if (error) {
+        throw error;
+      }
+      ev.emit("messages.update", [{ key: message.key, update: { message: message.message } }]);
+      return message;
+    },
+    sendMessage: async (jid, content, options = {}) => {
+      const userJid = authState.creds.me.id;
+      if (typeof content === "object" &&
+        "disappearingMessagesInChat" in content &&
+        typeof content["disappearingMessagesInChat"] !== "undefined" &&
+        isJidGroup(jid)) {
+        const { disappearingMessagesInChat } = content;
+        const value = typeof disappearingMessagesInChat === "boolean"
+          ? disappearingMessagesInChat
+            ? WA_DEFAULT_EPHEMERAL
+            : 0
+          : disappearingMessagesInChat;
+        await groupToggleEphemeral(jid, value);
+      }
+      else {
+        const fullMsg = await generateWAMessage(jid, content, {
+          logger,
+          userJid,
+          getUrlInfo: text => getUrlInfo(text, {
+            thumbnailWidth: linkPreviewImageThumbnailWidth,
+            fetchOpts: {
+              timeout: 3000,
+              ...(httpRequestOptions || {})
+            },
+            logger,
+            uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+          }),
+          getProfilePicUrl: sock.profilePictureUrl,
+          getCallLink: sock.createCallLink,
+          upload: waUploadToServer,
+          mediaCache: config.mediaCache,
+          options: config.options,
+          messageId: generateMessageIDV2(sock.user?.id),
+          ...options
+        });
+        const isEventMsg = "event" in content && !!content.event;
+        const isDeleteMsg = "delete" in content && !!content.delete;
+        const isEditMsg = "edit" in content && !!content.edit;
+        const isPinMsg = "pin" in content && !!content.pin;
+        const isPollMessage = "poll" in content && !!content.poll;
+        const additionalAttributes = {};
+        const additionalNodes = [];
+        if (isDeleteMsg) {
+          if (isJidGroup(content.delete?.remoteJid) && !content.delete?.fromMe) {
+            additionalAttributes.edit = "8";
+          }
+          else {
+            additionalAttributes.edit = "7";
+          }
+        }
+        else if (isEditMsg) {
+          additionalAttributes.edit = "1";
+        }
+        else if (isPinMsg) {
+          additionalAttributes.edit = "2";
+        }
+        else if (isPollMessage) {
+          additionalNodes.push({
+            tag: "meta",
+            attrs: {
+              polltype: "creation"
+            }
+          });
+        }
+        else if (isEventMsg) {
+          additionalNodes.push({
+            tag: "meta",
+            attrs: {
+              event_type: "creation"
+            }
+          });
+        }
+        await relayMessage(jid, fullMsg.message, {
+          messageId: fullMsg.key.id,
+          useCachedGroupMetadata: options.useCachedGroupMetadata,
+          additionalAttributes,
+          statusJidList: options.statusJidList,
+          additionalNodes
+        });
+        if (config.emitOwnEvents) {
+          process.nextTick(() => {
+            processingMutex.mutex(() => upsertMessage(fullMsg, "append"));
+          });
+        }
+        return fullMsg;
+      }
+    }
+  };
+};
+//=======================================================//