@kyyinfinite/baileys 1.0.0 → 2.0.0

package/lib/Socket/messages-send.js

@@ -1,1595 +1,1145 @@
-import NodeCache from "@cacheable/node-cache";
-import { Boom } from "@hapi/boom";
-import { proto } from "../../WAProto/index.js";
-import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from "../Defaults/index.js";
-import {
-  aggregateMessageKeysNotFromMe,
-  assertMediaContent,
-  bindWaitForEvent,
-  decryptMediaRetryData,
-  encodeNewsletterMessage,
-  encodeSignedDeviceIdentity,
-  encodeWAMessage,
-  encryptMediaRetryRequest,
-  extractDeviceJids,
-  generateMessageIDV2,
-  generateParticipantHashV2,
-  generateWAMessage,
-  generateWAMessageFromContent,
-  getStatusCodeForMediaRetry,
-  getUrlFromDirectPath,
-  getWAUploadToServer,
-  MessageRetryManager,
-  normalizeMessageContent,
-  prepareWAMessageMedia,
-  parseAndInjectE2ESessions,
-  unixTimestampSeconds,
-} from "../Utils/index.js";
-import {
-  generateTableContent,
-  generateTableContentV2,
-  generateListContent,
-  generateCodeBlockContent,
-  generateCodeBlockContentV2,
-  generateLinkContent,
-  generateLinkContentV2,
-  generateRichMessageContent,
-  generateLatexContent,
-  generateLatexImageContent,
-  generateLatexInlineImageContent,
-  generateUnifiedResponseContent,
-  captureUnifiedResponse,
-} from "../Utils/rich-messages.js";
-import { getUrlInfo } from "../Utils/link-preview.js";
-import { makeKeyedMutex } from "../Utils/make-mutex.js";
-import {
-  getMessageReportingToken,
-  shouldIncludeReportingToken,
-} from "../Utils/reporting-utils.js";
-import {
-  areJidsSameUser,
-  getAdditionalNode,
-  getBinaryNodeChild,
-  getBinaryNodeChildren,
-  isHostedLidUser,
-  isHostedPnUser,
-  isJidGroup,
-  isJidNewsletter,
-  isLidUser,
-  isPnUser,
-  jidDecode,
-  jidEncode,
-  jidNormalizedUser,
-  S_WHATSAPP_NET,
-} from "../WABinary/index.js";
-import { USyncQuery, USyncUser } from "../WAUSync/index.js";
-import { Dugong } from "./dugong.js";
-import { makeNewsletterSocket } from "./newsletter.js";
-const NATIVE_FLOW_BUTTON_MAP = {
-  review_and_pay: "order_details",
-  review_order: "order_status",
-  payment_info: "payment_info",
-  payment_status: "payment_status",
-  payment_method: "payment_method",
-};
-const getButtonType = (message) => {
-  const msg = normalizeMessageContent(message) || message;
-  if (msg?.buttonsMessage || msg?.listMessage)
-    return msg.listMessage ? "list" : "buttons";
-  const vm = msg?.viewOnceMessage?.message || msg?.viewOnceMessageV2?.message;
-  const im = vm?.interactiveMessage || msg?.interactiveMessage;
-  if (!im?.nativeFlowMessage) return null;
-  const btnName = im.nativeFlowMessage?.buttons?.[0]?.name;
-  if (btnName && NATIVE_FLOW_BUTTON_MAP[btnName])
-    return NATIVE_FLOW_BUTTON_MAP[btnName];
-  return "interactive";
-};
+import NodeCache from '@cacheable/node-cache';
+import { Boom } from '@hapi/boom';
+import { proto } from '../../WAProto/index.js';
+import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import { getUrlInfo } from '../Utils/link-preview.js';
+import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
+import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
+import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, resolveTcTokenJid, shouldSendNewTcToken, storeTcTokensFromIqResult } from '../Utils/tc-token-utils.js';
+import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, PSA_WID, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { USyncQuery, USyncUser } from '../WAUSync/index.js';
+import { makeNewsletterSocket } from './newsletter.js';
 export const makeMessagesSocket = (config) => {
-  const {
-    logger,
-    linkPreviewImageThumbnailWidth,
-    generateHighQualityLinkPreview,
-    options: httpRequestOptions,
-    patchMessageBeforeSending,
-    cachedGroupMetadata,
-    enableRecentMessageCache,
-    maxMsgRetryCount,
-  } = config;
-  const sock = makeNewsletterSocket(config);
-  const {
-    ev,
-    authState,
-    messageMutex,
-    signalRepository,
-    upsertMessage,
-    query,
-    fetchPrivacySettings,
-    sendNode,
-    groupMetadata,
-    groupToggleEphemeral,
-  } = sock;
-  const userDevicesCache =
-    config.userDevicesCache ||
-    new NodeCache({
-      stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
-      useClones: false,
-    });
-  const peerSessionsCache = new NodeCache({
-    stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
-    useClones: false,
-  });
-  // Initialize message retry manager if enabled
-  const messageRetryManager = enableRecentMessageCache
-    ? new MessageRetryManager(logger, maxMsgRetryCount)
-    : null;
-  // Prevent race conditions in Signal session encryption by user
-  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 { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
+    const sock = makeNewsletterSocket(config);
+    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
+    /**
+     * Set of tctoken storage JIDs with a fire-and-forget `issuePrivacyTokens` IQ in flight.
+     * Prevents duplicate IQs from rapid back-to-back sends before `senderTimestamp` persists.
+     * Entries are always removed in `.finally()`, so the set is bounded by concurrency.
+     */
+    const inFlightTcTokenIssuance = new Set();
+    const userDevicesCache = config.userDevicesCache ||
+        new NodeCache({
+            stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
+            useClones: false
         });
-        const mediaConnNode = getBinaryNodeChild(result, "media_conn");
-        // TODO: explore full length of data that whatsapp provides
+    /** Serializes writes to userDevicesCache across USync refresh and device-notification handling. */
+    const devicesMutex = makeMutex();
+    // Initialize message retry manager if enabled
+    const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;
+    // Prevent race conditions in Signal session encryption by user
+    const encryptionMutex = makeKeyedMutex();
+    let mediaConn;
+    /** Per-socket media host; updated whenever media_conn is fetched. Defaults to the public WhatsApp host. */
+    let mediaHost = DEF_MEDIA_HOST;
+    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');
+                // TODO: explore full length of data that whatsapp provides
+                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');
+                if (node.hosts[0]) {
+                    mediaHost = node.hosts[0].hostname;
+                }
+                return node;
+            })();
+        }
+        return mediaConn;
+    };
+    /**
+     * generic send receipt function
+     * used for receipts of phone call, read, delivery etc.
+     * */
+    const sendReceipt = async (jid, participant, messageIds, type) => {
+        if (!messageIds || messageIds.length === 0) {
+            throw new Boom('missing ids in receipt');
+        }
         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(),
+            tag: 'receipt',
+            attrs: {
+                id: messageIds[0]
+            }
         };
-        logger.debug("fetched media conn");
-        return node;
-      })();
-    }
-    return mediaConn;
-  };
-  /**
-   * generic send receipt function
-   * used for receipts of phone call, read, delivery etc.
-   * */
-  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);
-  };
-  /** Correctly bulk send receipts to multiple chats, participants */
-  const sendReceipts = async (keys, type) => {
-    const recps = aggregateMessageKeysNotFromMe(keys);
-    for (const { jid, participant, messageIds } of recps) {
-      await sendReceipt(jid, participant, messageIds, type);
-    }
-  };
-  /** Bulk read messages. Keys can be from different chats & participants */
-  const readMessages = async (keys) => {
-    const privacySettings = await fetchPrivacySettings();
-    // based on privacy settings, we have to change the read type
-    const readType =
-      privacySettings.readreceipts === "all" ? "read" : "read-self";
-    await sendReceipts(keys, readType);
-  };
-  /** Fetch all the devices we've to send a message to */
-  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;
+        const isReadReceipt = type === 'read' || type === 'read-self';
+        if (isReadReceipt) {
+            node.attrs.t = unixTimestampSeconds().toString();
         }
-        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);
+        if (type === 'sender' && (isPnUser(jid) || isLidUser(jid))) {
+            node.attrs.recipient = jid;
+            node.attrs.to = participant;
         }
-      } 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)); // todo: investigate - the idea here is that <user> should have an inline lid field with the lid being the pn equivalent
-    }
-    const result = await sock.executeUSyncQuery(query);
-    if (result) {
-      // TODO: LID MAP this stuff (lid protocol will now return lid with devices)
-      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 })),
-        );
-        // Force-refresh sessions for newly mapped LIDs to align identity addressing
-        try {
-          const lids = lidResults.map((a) => a.lid);
-          if (lids.length) {
-            await assertSessions(lids, true);
-          }
-        } catch (e) {
-          logger.warn(
-            { e, count: lidResults.length },
-            "failed to assert sessions for newly mapped LIDs",
-          );
+        else {
+            node.attrs.to = jid;
+            if (participant) {
+                node.attrs.participant = participant;
+            }
         }
-      }
-      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);
-      }
-      // Process each user's devices as a group for bulk LID migration
-      for (const [user, userDevices] of Object.entries(deviceMap)) {
-        const isLidUser = requestedLidUsers.has(user);
-        // Process all devices for this 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 (type) {
+            node.attrs.type = type;
         }
-      }
-      if (userDevicesCache.mset) {
-        // if the cache supports mset, we can set all devices in one go
-        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 remainingMessageIds = messageIds.slice(1);
+        if (remainingMessageIds.length) {
+            node.content = [
+                {
+                    tag: 'list',
+                    attrs: {},
+                    content: remainingMessageIds.map(id => ({
+                        tag: 'item',
+                        attrs: { id }
+                    }))
+                }
+            ];
         }
-      }
-      const userDeviceUpdates = {};
-      for (const [userId, devices] of Object.entries(deviceMap)) {
-        if (devices && devices.length > 0) {
-          userDeviceUpdates[userId] = devices.map(
-            (d) => d.device?.toString() || "0",
-          );
+        logger.debug({ attrs: node.attrs, messageIds }, 'sending receipt for messages');
+        await sendNode(node);
+    };
+    /** Correctly bulk send receipts to multiple chats, participants */
+    const sendReceipts = async (keys, type) => {
+        const recps = aggregateMessageKeysNotFromMe(keys);
+        for (const { jid, participant, messageIds } of recps) {
+            await sendReceipt(jid, participant, messageIds, type);
         }
-      }
-      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");
+    };
+    /** Bulk read messages. Keys can be from different chats & participants */
+    const readMessages = async (keys) => {
+        const privacySettings = await fetchPrivacySettings();
+        // based on privacy settings, we have to change the read type
+        const readType = privacySettings.readreceipts === 'all' ? 'read' : 'read-self';
+        await sendReceipts(keys, readType);
+    };
+    /** Fetch all the devices we've to send a message to */
+    const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
+        const deviceResults = [];
+        if (!useCache) {
+            logger.debug('not using cache for devices');
         }
-      }
-    }
-    return deviceResults;
-  };
-  /**
-   * Update Member Label
-   */
-  const updateMemberLabel = (jid, memberLabel) => {
-    return relayMessage(
-      jid,
-      {
-        protocolMessage: {
-          type: proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE,
-          memberLabel: {
-            label: memberLabel?.slice(0, 30),
-            labelTimestamp: unixTimestampSeconds(),
-          },
-        },
-      },
-      {
-        additionalNodes: [
-          {
-            tag: "meta",
-            attrs: {
-              tag_reason: "user_update",
-              appdata: "member_tag",
-            },
-            content: undefined,
-          },
-        ],
-      },
-    );
-  };
-  const assertSessions = async (jids, force) => {
-    let didFetchNewSession = false;
-    const uniqueJids = [...new Set(jids)]; // Deduplicate JIDs
-    const jidsRequiringFetch = [];
-    logger.debug({ jids }, "assertSessions call with jids");
-    // Check peerSessionsCache and validate sessions using libsignal loadSession
-    for (const jid of uniqueJids) {
-      const signalId = signalRepository.jidToSignalProtocolAddress(jid);
-      const cachedSession = peerSessionsCache.get(signalId);
-      if (cachedSession !== undefined) {
-        if (cachedSession && !force) {
-          continue; // Session exists in cache
+        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);
         }
-      } else {
-        const sessionValidation = await signalRepository.validateSession(jid);
-        const hasSession = sessionValidation.exists;
-        peerSessionsCache.set(signalId, hasSession);
-        if (hasSession && !force) {
-          continue;
+        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);
+            }
         }
-      }
-      jidsRequiringFetch.push(jid);
-    }
-    if (jidsRequiringFetch.length) {
-      // LID if mapped, otherwise original
-      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) => {
-              const attrs = { jid };
-              if (force) attrs.reason = "identity";
-              return { tag: "user", attrs };
-            }),
-          },
-        ],
-      });
-      await parseAndInjectE2ESessions(result, signalRepository);
-      didFetchNewSession = true;
-      // Cache fetched sessions using wire JIDs
-      for (const wireJid of wireJids) {
-        const signalId = signalRepository.jidToSignalProtocolAddress(wireJid);
-        peerSessionsCache.set(signalId, true);
-      }
-    }
-    return didFetchNewSession;
-  };
-  const sendPeerDataOperationMessage = async (pdoMessage) => {
-    //TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
-    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 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 }) => {
-        try {
-          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");
+        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 bytes = encodeWAMessage(msgToEncrypt);
-          const mutexKey = jid;
-          const node = await encryptionMutex.mutex(mutexKey, async () => {
-            const { type, ciphertext } = await signalRepository.encryptMessage({
-              jid,
-              data: bytes,
+        }
+        const query = new USyncQuery().withContext('message').withDeviceProtocol().withLIDProtocol();
+        for (const jid of toFetch) {
+            query.withUser(new USyncUser().withId(jid)); // todo: investigate - the idea here is that <user> should have an inline lid field with the lid being the pn equivalent
+        }
+        const result = await sock.executeUSyncQuery(query);
+        if (result) {
+            // TODO: LID MAP this stuff (lid protocol will now return lid with devices)
+            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 })));
+                // Force-refresh sessions for newly mapped LIDs to align identity addressing
+                try {
+                    const lids = lidResults.map(a => a.lid);
+                    if (lids.length) {
+                        await assertSessions(lids, true);
+                    }
+                }
+                catch (e) {
+                    logger.warn({ e, count: lidResults.length }, 'failed to assert sessions for newly mapped LIDs');
+                }
+            }
+            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);
+            }
+            // Process each user's devices as a group for bulk LID migration
+            for (const [user, userDevices] of Object.entries(deviceMap)) {
+                const isLidUser = requestedLidUsers.has(user);
+                // Process all devices for this 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');
+                }
+            }
+            await devicesMutex.mutex(async () => {
+                if (userDevicesCache.mset) {
+                    // if the cache supports mset, we can set all devices in one go
+                    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]);
+                    }
+                }
             });
-            if (type === "pkmsg") {
-              shouldIncludeDeviceIdentity = true;
+            const userDeviceUpdates = {};
+            for (const [userId, devices] of Object.entries(deviceMap)) {
+                if (devices && devices.length > 0) {
+                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString() || '0');
+                }
             }
-            return {
-              tag: "to",
-              attrs: { jid },
-              content: [
+            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;
+    };
+    /**
+     * Update Member Label
+     */
+    const updateMemberLabel = (jid, memberLabel) => {
+        return relayMessage(jid, {
+            protocolMessage: {
+                type: proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE,
+                memberLabel: {
+                    label: memberLabel?.slice(0, 30),
+                    labelTimestamp: unixTimestampSeconds()
+                }
+            }
+        }, {
+            additionalNodes: [
                 {
-                  tag: "enc",
-                  attrs: { v: "2", type, ...(extraAttrs || {}) },
-                  content: ciphertext,
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    };
+    const assertSessions = async (jids, force) => {
+        let didFetchNewSession = false;
+        const uniqueJids = [...new Set(jids)];
+        const jidsRequiringFetch = [];
+        logger.debug({ jids }, 'assertSessions call with jids');
+        for (const jid of uniqueJids) {
+            if (!force) {
+                const sessionValidation = await signalRepository.validateSession(jid);
+                if (sessionValidation.exists) {
+                    continue;
+                }
+            }
+            jidsRequiringFetch.push(jid);
+        }
+        if (jidsRequiringFetch.length) {
+            // LID if mapped, otherwise original
+            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
                 },
-              ],
-            };
-          });
-          return node;
-        } catch (err) {
-          logger.error({ jid, err }, "Failed to encrypt for recipient");
-          return null;
+                content: [
+                    {
+                        tag: 'key',
+                        attrs: {},
+                        content: wireJids.map(jid => {
+                            const attrs = { jid };
+                            if (force)
+                                attrs.reason = 'identity';
+                            return { tag: 'user', attrs };
+                        })
+                    }
+                ]
+            });
+            await parseAndInjectE2ESessions(result, signalRepository);
+            didFetchNewSession = true;
         }
-      },
-    );
-    const nodes = (await Promise.all(encryptionPromises)).filter(
-      (node) => node !== null,
-    );
-    if (recipientJids.length > 0 && nodes.length === 0) {
-      throw new Boom("All encryptions failed", { statusCode: 500 });
-    }
-    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 isGroupOrStatus = isGroup || isStatus;
-    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 = [];
-    let reportingMessage;
-    const meMsg = {
-      deviceSentMessage: {
-        destinationJid,
-        message,
-      },
-      messageContextInfo: message.messageContextInfo,
+        return didFetchNewSession;
     };
-    const extraAttrs = {};
-    if (participant) {
-      if (!isGroup && !isStatus) {
-        additionalAttributes = {
-          ...additionalAttributes,
-          device_fanout: "false",
+    const sendPeerDataOperationMessage = async (pdoMessage) => {
+        //TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
+        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 { user, device } = jidDecode(participant.jid);
-      devices.push({
-        user,
-        device,
-        jid: participant.jid,
-      });
-    }
-    await authState.keys.transaction(async () => {
-      const mediaType = getMediaType(
-        normalizeMessageContent(message) || message,
-      );
-      if (mediaType) {
-        extraAttrs["mediatype"] = mediaType;
-      }
-      if (isNewsletter) {
-        const patched = patchMessageBeforeSending
-          ? await patchMessageBeforeSending(message, [])
-          : message;
-        const bytes = encodeNewsletterMessage(patched);
-        binaryNodeContent.push({
-          tag: "plaintext",
-          attrs: extraAttrs || {},
-          content: bytes,
+        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' }
+                }
+            ]
         });
-        const stanza = {
-          tag: "message",
-          attrs: {
-            to: jid,
-            id: msgId,
-            type: getMessageType(message),
-            ...(additionalAttributes || {}),
-          },
-          content: binaryNodeContent,
+        return msgId;
+    };
+    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 }) => {
+            try {
+                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;
+            }
+            catch (err) {
+                logger.error({ jid, err }, 'Failed to encrypt for recipient');
+                return null;
+            }
+        });
+        const nodes = (await Promise.all(encryptionPromises)).filter(node => node !== null);
+        if (recipientJids.length > 0 && nodes.length === 0) {
+            throw new Boom('All encryptions failed', { statusCode: 500 });
+        }
+        return { nodes, shouldIncludeDeviceIdentity };
+    };
+    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }) => {
+        const meId = assertMeId(authState.creds);
+        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 isGroupOrStatus = isGroup || isStatus;
+        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 = [];
+        let reportingMessage;
+        const meMsg = {
+            deviceSentMessage: {
+                destinationJid,
+                message
+            },
+            messageContextInfo: message.messageContextInfo
         };
-        logger.debug({ msgId }, `sending newsletter message to ${jid}`);
-        await sendNode(stanza);
-        return;
-      }
-      if (
-        normalizeMessageContent(message)?.pinInChatMessage ||
-        normalizeMessageContent(message)?.reactionMessage
-      ) {
-        extraAttrs["decrypt-fail"] = "hide"; // todo: expand for reactions and other types
-      }
-      if (isGroupOrStatus && !isRetryResend) {
-        const [groupData, senderKeyMap] = await Promise.all([
-          (async () => {
-            let groupData =
-              useCachedGroupMetadata && cachedGroupMetadata
-                ? await cachedGroupMetadata(jid)
-                : undefined; // todo: should we rely on the cache specially if the cache is outdated and the metadata has new fields?
-            if (groupData && Array.isArray(groupData?.participants)) {
-              logger.trace(
-                { jid, participants: groupData.participants.length },
-                "using cached group metadata",
-              );
-            } else if (!isStatus) {
-              groupData = await groupMetadata(jid); // TODO: start storing group participant list + addr mode in Signal & stop relying on this
+        const extraAttrs = {};
+        if (participant) {
+            if (!isGroup && !isStatus) {
+                additionalAttributes = { ...additionalAttributes, device_fanout: 'false' };
             }
-            return groupData;
-          })(),
-          (async () => {
-            if (!participant && !isStatus) {
-              // what if sender memory is less accurate than the cached metadata
-              // on participant change in group, we should do sender memory manipulation
-              const result = await authState.keys.get("sender-key-memory", [
-                jid,
-              ]); // TODO: check out what if the sender key memory doesn't include the LID stuff now?
-              return result[jid] || {};
+            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 || normalizeMessageContent(message)?.reactionMessage) {
+                extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
             }
-            return {};
-          })(),
-        ]);
-        const participantsList = groupData
-          ? groupData.participants.map((p) => p.id)
-          : [];
-        if (groupData?.ephemeralDuration && groupData.ephemeralDuration > 0) {
-          additionalAttributes = {
-            ...additionalAttributes,
-            expiration: groupData.ephemeralDuration.toString(),
-          };
+            if (isGroupOrStatus && !isRetryResend) {
+                const [groupData, senderKeyMap] = await Promise.all([
+                    (async () => {
+                        let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined; // todo: should we rely on the cache specially if the cache is outdated and the metadata has new fields?
+                        if (groupData && Array.isArray(groupData?.participants)) {
+                            logger.trace({ jid, participants: groupData.participants.length }, 'using cached group metadata');
+                        }
+                        else if (!isStatus) {
+                            groupData = await groupMetadata(jid); // TODO: start storing group participant list + addr mode in Signal & stop relying on this
+                        }
+                        return groupData;
+                    })(),
+                    (async () => {
+                        if (!participant && !isStatus) {
+                            // what if sender memory is less accurate than the cached metadata
+                            // on participant change in group, we should do sender memory manipulation
+                            const result = await authState.keys.get('sender-key-memory', [jid]); // TODO: check out what if the sender key memory doesn't include the LID stuff now?
+                            return result[jid] || {};
+                        }
+                        return {};
+                    })()
+                ]);
+                const participantsList = groupData ? groupData.participants.map(p => p.id) : [];
+                if (groupData?.ephemeralDuration && groupData.ephemeralDuration > 0) {
+                    additionalAttributes = {
+                        ...additionalAttributes,
+                        expiration: groupData.ephemeralDuration.toString()
+                    };
+                }
+                if (isStatus && statusJidList) {
+                    participantsList.push(...statusJidList);
+                }
+                const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false);
+                devices.push(...additionalDevices);
+                if (isGroup) {
+                    additionalAttributes = {
+                        ...additionalAttributes,
+                        addressing_mode: groupData?.addressingMode || 'lid'
+                    };
+                }
+                const patched = await patchMessageBeforeSending(message);
+                if (Array.isArray(patched)) {
+                    throw new Boom('Per-jid patching is not supported in groups');
+                }
+                const bytes = encodeWAMessage(patched);
+                reportingMessage = 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) {
+                        //todo: revamp all this logic
+                        // the goal is to follow with what I said above for each group, and instead of a true false map of ids, we can set an array full of those the app has already sent pkmsgs
+                        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);
+                }
+                binaryNodeContent.push({
+                    tag: 'enc',
+                    attrs: { v: '2', type: 'skmsg', ...extraAttrs },
+                    content: ciphertext
+                });
+                await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
+            }
+            else {
+                // ADDRESSING CONSISTENCY: Match own identity to conversation context
+                // TODO: investigate if this is true
+                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 patchedForReporting = await patchMessageBeforeSending(message, [jid]);
+                    reportingMessage = Array.isArray(patchedForReporting)
+                        ? patchedForReporting.find(item => item.recipientJid === jid) || patchedForReporting[0]
+                        : patchedForReporting;
+                }
+                if (!isRetryResend) {
+                    const targetUserServer = isLid ? 'lid' : 's.whatsapp.net';
+                    devices.push({
+                        user,
+                        device: 0,
+                        jid: jidEncode(user, targetUserServer, 0) // rajeh, todo: this entire logic is convoluted and weird.
+                    });
+                    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') {
+                        // Clear placeholders and enumerate actual devices
+                        devices.length = 0;
+                        // Use conversation-appropriate sender identity
+                        const senderIdentity = isLid && meLid
+                            ? jidEncode(jidDecode(meLid)?.user, 'lid', undefined)
+                            : jidEncode(jidDecode(meId)?.user, 's.whatsapp.net', undefined);
+                        // Enumerate devices for sender and target with consistent addressing
+                        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;
+                    }
+                    // Check if this is our device (could match either PN or LID user)
+                    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([
+                    // For own devices: use DSM if available (1:1 chats only)
+                    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 (isRetryResend) {
+                const isParticipantLid = isLidUser(participant.jid);
+                const isMe = areJidsSameUser(participant.jid, isParticipantLid ? meLid : meId);
+                let messageToSend = message;
+                if (isGroupOrStatus) {
+                    let groupSenderIdentity;
+                    if (meLid && (await signalRepository.hasSenderKey({ group: destinationJid, meId: meLid }))) {
+                        groupSenderIdentity = meLid;
+                    }
+                    else if (await signalRepository.hasSenderKey({ group: destinationJid, meId })) {
+                        groupSenderIdentity = meId;
+                    }
+                    if (groupSenderIdentity) {
+                        try {
+                            const skdm = await signalRepository.getSenderKeyDistributionMessage({
+                                group: destinationJid,
+                                meId: groupSenderIdentity
+                            });
+                            messageToSend = {
+                                ...message,
+                                senderKeyDistributionMessage: {
+                                    groupId: destinationJid,
+                                    axolotlSenderKeyDistributionMessage: skdm
+                                }
+                            };
+                        }
+                        catch (err) {
+                            logger.warn({ err, jid: destinationJid }, 'failed to build SKDM for retry, sending without it');
+                        }
+                    }
+                }
+                const encodedMessageToSend = isMe
+                    ? encodeWAMessage({
+                        deviceSentMessage: {
+                            destinationJid,
+                            message: messageToSend
+                        }
+                    })
+                    : encodeWAMessage(messageToSend);
+                const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
+                    data: encodedMessageToSend,
+                    jid: participant.jid
+                });
+                binaryNodeContent.push({
+                    tag: 'enc',
+                    attrs: {
+                        v: '2',
+                        type,
+                        count: participant.count.toString()
+                    },
+                    content: encryptedContent
+                });
+            }
+            if (participants.length) {
+                if (additionalAttributes?.['category'] === 'peer') {
+                    const peerNode = participants[0]?.content?.[0];
+                    if (peerNode) {
+                        binaryNodeContent.push(peerNode); // push only enc
+                    }
+                }
+                else {
+                    binaryNodeContent.push({
+                        tag: 'participants',
+                        attrs: {},
+                        content: participants
+                    });
+                }
+            }
+            const stanza = {
+                tag: 'message',
+                attrs: {
+                    id: msgId,
+                    to: destinationJid,
+                    type: getMessageType(message),
+                    ...(additionalAttributes || {})
+                },
+                content: binaryNodeContent
+            };
+            // if the participant to send to is explicitly specified (generally retry recp)
+            // ensure the message is only sent to that person
+            // if a retry receipt is sent to everyone -- it'll fail decryption for everyone else who received the msg
+            if (participant) {
+                if (isJidGroup(destinationJid)) {
+                    stanza.attrs.to = destinationJid;
+                    stanza.attrs.participant = participant.jid;
+                }
+                else if (areJidsSameUser(participant.jid, meId)) {
+                    stanza.attrs.to = participant.jid;
+                    stanza.attrs.recipient = destinationJid;
+                }
+                else {
+                    stanza.attrs.to = participant.jid;
+                }
+            }
+            else {
+                stanza.attrs.to = destinationJid;
+            }
+            if (shouldIncludeDeviceIdentity) {
+                ;
+                stanza.content.push({
+                    tag: 'device-identity',
+                    attrs: {},
+                    content: encodeSignedDeviceIdentity(authState.creds.account, true)
+                });
+                logger.debug({ jid }, 'adding device identity');
+            }
+            if (!isNewsletter &&
+                !isRetryResend &&
+                reportingMessage?.messageContextInfo?.messageSecret &&
+                shouldIncludeReportingToken(reportingMessage)) {
+                try {
+                    const encoded = encodeWAMessage(reportingMessage);
+                    const reportingKey = {
+                        id: msgId,
+                        fromMe: true,
+                        remoteJid: destinationJid,
+                        participant: participant?.jid
+                    };
+                    const reportingNode = await getMessageReportingToken(encoded, reportingMessage, reportingKey);
+                    if (reportingNode) {
+                        ;
+                        stanza.content.push(reportingNode);
+                        logger.trace({ jid }, 'added reporting token to message');
+                    }
+                }
+                catch (error) {
+                    logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
+                }
+            }
+            // WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
+            const isPeerMessage = additionalAttributes?.['category'] === 'peer';
+            const is1on1Send = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage;
+            // Resolve destination to LID for tctoken storage — matches Signal session key pattern
+            const tcTokenJid = is1on1Send ? await resolveTcTokenJid(destinationJid, getLIDForPN) : destinationJid;
+            const contactTcTokenData = is1on1Send ? await authState.keys.get('tctoken', [tcTokenJid]) : {};
+            const existingTokenEntry = contactTcTokenData[tcTokenJid];
+            let tcTokenBuffer = existingTokenEntry?.token;
+            // Treat expired tokens the same as missing — clear from cache
+            if (tcTokenBuffer?.length && isTcTokenExpired(existingTokenEntry?.timestamp)) {
+                logger.debug({ jid: destinationJid, timestamp: existingTokenEntry?.timestamp }, 'tctoken expired, clearing');
+                tcTokenBuffer = undefined;
+                // Preserve senderTimestamp so the fire-and-forget issuance dedupe survives cleanup.
+                const cleared = existingTokenEntry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: existingTokenEntry.senderTimestamp }
+                    : null;
+                try {
+                    await authState.keys.set({ tctoken: { [tcTokenJid]: cleared } });
+                }
+                catch (err) {
+                    logger.debug({ jid: destinationJid, err: err?.message }, 'failed to persist tctoken expiry cleanup');
+                }
+            }
+            if (tcTokenBuffer?.length && sock.serverProps.privacyTokenOn1to1) {
+                ;
+                stanza.content.push({
+                    tag: 'tctoken',
+                    attrs: {},
+                    content: tcTokenBuffer
+                });
+            }
+            if (additionalNodes && additionalNodes.length > 0) {
+                ;
+                stanza.content.push(...additionalNodes);
+            }
+            logger.debug({ msgId }, `sending message to ${participants.length} devices`);
+            await sendNode(stanza);
+            // Fire-and-forget: issue our token to the contact AFTER message send.
+            // WA Web skips protocol messages and PSA/bot contacts (TcTokenChatAction: isRegularUser)
+            const isProtocolMsg = !!normalizeMessageContent(message)?.protocolMessage;
+            const isBotOrPSA = destinationJid === PSA_WID || isJidBot(destinationJid) || isJidMetaAI(destinationJid);
+            if (is1on1Send &&
+                !isProtocolMsg &&
+                !isBotOrPSA &&
+                shouldSendNewTcToken(existingTokenEntry?.senderTimestamp) &&
+                !inFlightTcTokenIssuance.has(tcTokenJid)) {
+                inFlightTcTokenIssuance.add(tcTokenJid);
+                const issueTimestamp = unixTimestampSeconds();
+                const getPNForLID = signalRepository.lidMapping.getPNForLID.bind(signalRepository.lidMapping);
+                resolveIssuanceJid(destinationJid, sock.serverProps.lidTrustedTokenIssueToLid, getLIDForPN, getPNForLID)
+                    .then(issueJid => issuePrivacyTokens([issueJid], issueTimestamp))
+                    .then(async (result) => {
+                    await storeTcTokensFromIqResult({
+                        result,
+                        fallbackJid: tcTokenJid,
+                        keys: authState.keys,
+                        getLIDForPN
+                    });
+                    const currentData = await authState.keys.get('tctoken', [tcTokenJid]);
+                    const currentEntry = currentData[tcTokenJid];
+                    const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [tcTokenJid]);
+                    await authState.keys.set({
+                        tctoken: {
+                            [tcTokenJid]: {
+                                token: Buffer.alloc(0),
+                                ...currentEntry,
+                                senderTimestamp: issueTimestamp
+                            },
+                            ...indexWrite
+                        }
+                    });
+                })
+                    .catch(err => {
+                    logger.debug({ jid: destinationJid, err: err?.message }, 'fire-and-forget tctoken issuance failed');
+                })
+                    .finally(() => {
+                    inFlightTcTokenIssuance.delete(tcTokenJid);
+                });
+            }
+            // Add message to retry cache if enabled
+            if (messageRetryManager && !participant) {
+                messageRetryManager.addRecentMessage(destinationJid, msgId, message);
+            }
+        }, meId);
+        return msgId;
+    };
+    const getMessageType = (message) => {
+        const normalizedMessage = normalizeMessageContent(message);
+        if (!normalizedMessage)
+            return 'text';
+        if (normalizedMessage.reactionMessage || normalizedMessage.encReactionMessage) {
+            return 'reaction';
         }
-        if (isStatus && statusJidList) {
-          participantsList.push(...statusJidList);
+        if (normalizedMessage.pollCreationMessage ||
+            normalizedMessage.pollCreationMessageV2 ||
+            normalizedMessage.pollCreationMessageV3 ||
+            normalizedMessage.pollUpdateMessage) {
+            return 'poll';
         }
-        const additionalDevices = await getUSyncDevices(
-          participantsList,
-          !!useUserDevicesCache,
-          false,
-        );
-        devices.push(...additionalDevices);
-        if (isGroup) {
-          additionalAttributes = {
-            ...additionalAttributes,
-            addressing_mode: groupData?.addressingMode || "lid",
-          };
+        if (normalizedMessage.eventMessage) {
+            return 'event';
         }
-        const patched = await patchMessageBeforeSending(message);
-        if (Array.isArray(patched)) {
-          throw new Boom("Per-jid patching is not supported in groups");
+        if (getMediaType(normalizedMessage) !== '') {
+            return 'media';
         }
-        const bytes = encodeWAMessage(patched);
-        reportingMessage = 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
-          ) {
-            //todo: revamp all this logic
-            // the goal is to follow with what I said above for each group, and instead of a true false map of ids, we can set an array full of those the app has already sent pkmsgs
-            senderKeyRecipients.push(deviceJid);
-            senderKeyMap[deviceJid] = true;
-          }
+        return 'text';
+    };
+    const getMediaType = (message) => {
+        if (message.imageMessage) {
+            return 'image';
         }
-        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);
+        else if (message.videoMessage) {
+            return message.videoMessage.gifPlayback ? 'gif' : 'video';
         }
-        binaryNodeContent.push({
-          tag: "enc",
-          attrs: { v: "2", type: "skmsg", ...extraAttrs },
-          content: ciphertext,
-        });
-        await authState.keys.set({
-          "sender-key-memory": { [jid]: senderKeyMap },
-        });
-      } else {
-        // ADDRESSING CONSISTENCY: Match own identity to conversation context
-        // TODO: investigate if this is true
-        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",
-          );
+        else if (message.audioMessage) {
+            return message.audioMessage.ptt ? 'ptt' : 'audio';
         }
-        const { user: ownUser } = jidDecode(ownId);
-        if (!participant) {
-          const patchedForReporting = await patchMessageBeforeSending(message, [
-            jid,
-          ]);
-          reportingMessage = Array.isArray(patchedForReporting)
-            ? patchedForReporting.find((item) => item.recipientJid === jid) ||
-              patchedForReporting[0]
-            : patchedForReporting;
+        else if (message.contactMessage) {
+            return 'vcard';
         }
-        if (!isRetryResend) {
-          const targetUserServer = isLid ? "lid" : "s.whatsapp.net";
-          devices.push({
-            user,
-            device: 0,
-            jid: jidEncode(user, targetUserServer, 0), // rajeh, todo: this entire logic is convoluted and weird.
-          });
-          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") {
-            // Clear placeholders and enumerate actual devices
-            devices.length = 0;
-            // Use conversation-appropriate sender identity
-            const senderIdentity =
-              isLid && meLid
-                ? jidEncode(jidDecode(meLid)?.user, "lid", undefined)
-                : jidEncode(jidDecode(meId)?.user, "s.whatsapp.net", undefined);
-            // Enumerate devices for sender and target with consistent addressing
-            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",
-            );
-          }
+        else if (message.documentMessage) {
+            return 'document';
         }
-        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;
-          }
-          // Check if this is our device (could match either PN or LID user)
-          const isMe = user === mePnUser || user === meLidUser;
-          if (isMe) {
-            meRecipients.push(jid);
-          } else {
-            otherRecipients.push(jid);
-          }
-          allRecipients.push(jid);
+        else if (message.contactsArrayMessage) {
+            return 'contact_array';
         }
-        await assertSessions(allRecipients);
-        const [
-          { nodes: meNodes, shouldIncludeDeviceIdentity: s1 },
-          { nodes: otherNodes, shouldIncludeDeviceIdentity: s2 },
-        ] = await Promise.all([
-          // For own devices: use DSM if available (1:1 chats only)
-          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,
-          ]);
+        else if (message.liveLocationMessage) {
+            return 'livelocation';
         }
-        shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2;
-      }
-      if (isRetryResend) {
-        const isParticipantLid = isLidUser(participant.jid);
-        const isMe = areJidsSameUser(
-          participant.jid,
-          isParticipantLid ? meLid : meId,
-        );
-        const encodedMessageToSend = isMe
-          ? encodeWAMessage({
-              deviceSentMessage: {
-                destinationJid,
-                message,
-              },
-            })
-          : encodeWAMessage(message);
-        const { type, ciphertext: encryptedContent } =
-          await signalRepository.encryptMessage({
-            data: encodedMessageToSend,
-            jid: participant.jid,
-          });
-        binaryNodeContent.push({
-          tag: "enc",
-          attrs: {
-            v: "2",
-            type,
-            count: participant.count.toString(),
-          },
-          content: encryptedContent,
-        });
-      }
-      if (participants.length) {
-        if (additionalAttributes?.["category"] === "peer") {
-          const peerNode = participants[0]?.content?.[0];
-          if (peerNode) {
-            binaryNodeContent.push(peerNode); // push only enc
-          }
-        } else {
-          binaryNodeContent.push({
-            tag: "participants",
-            attrs: {},
-            content: participants,
-          });
+        else if (message.stickerMessage) {
+            return 'sticker';
         }
-      }
-      const stanza = {
-        tag: "message",
-        attrs: {
-          id: msgId,
-          to: destinationJid,
-          type: getMessageType(message),
-          ...(additionalAttributes || {}),
-        },
-        content: binaryNodeContent,
-      };
-      // if the participant to send to is explicitly specified (generally retry recp)
-      // ensure the message is only sent to that person
-      // if a retry receipt is sent to everyone -- it'll fail decryption for everyone else who received the msg
-      if (participant) {
-        if (isJidGroup(destinationJid)) {
-          stanza.attrs.to = destinationJid;
-          stanza.attrs.participant = participant.jid;
-        } else if (areJidsSameUser(participant.jid, meId)) {
-          stanza.attrs.to = participant.jid;
-          stanza.attrs.recipient = destinationJid;
-        } else {
-          stanza.attrs.to = participant.jid;
+        else if (message.listMessage) {
+            return 'list';
         }
-      } else {
-        stanza.attrs.to = destinationJid;
-      }
-      if (shouldIncludeDeviceIdentity) {
-        stanza.content.push({
-          tag: "device-identity",
-          attrs: {},
-          content: encodeSignedDeviceIdentity(authState.creds.account, true),
-        });
-        logger.debug({ jid }, "adding device identity");
-      }
-      if (
-        !isNewsletter &&
-        !isRetryResend &&
-        reportingMessage?.messageContextInfo?.messageSecret &&
-        shouldIncludeReportingToken(reportingMessage)
-      ) {
-        try {
-          const encoded = encodeWAMessage(reportingMessage);
-          const reportingKey = {
-            id: msgId,
-            fromMe: true,
-            remoteJid: destinationJid,
-            participant: participant?.jid,
-          };
-          const reportingNode = await getMessageReportingToken(
-            encoded,
-            reportingMessage,
-            reportingKey,
-          );
-          if (reportingNode) {
-            stanza.content.push(reportingNode);
-            logger.trace({ jid }, "added reporting token to message");
-          }
-        } catch (error) {
-          logger.warn(
-            { jid, trace: error?.stack },
-            "failed to attach reporting token",
-          );
+        else if (message.listResponseMessage) {
+            return 'list_response';
         }
-      }
-      const contactTcTokenData =
-        !isGroup && !isRetryResend && !isStatus
-          ? await authState.keys.get("tctoken", [destinationJid])
-          : {};
-      const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
-      if (tcTokenBuffer) {
-        stanza.content.push({
-          tag: "tctoken",
-          attrs: {},
-          content: tcTokenBuffer,
-        });
-      }
-      if (additionalNodes && additionalNodes.length > 0) {
-        stanza.content.push(...additionalNodes);
-      }
-      const buttonType = getButtonType(message);
-      if (buttonType && !isNewsletter && !isStatus) {
-        const bizNodes = getAdditionalNode(buttonType);
-        stanza.content.push(...bizNodes);
-      }
-      logger.debug(
-        { msgId },
-        `sending message to ${participants.length} devices`,
-      );
-      await sendNode(stanza);
-      // Add message to retry cache if enabled
-      if (messageRetryManager && !participant) {
-        messageRetryManager.addRecentMessage(destinationJid, msgId, message);
-      }
-    }, meId);
-    return msgId;
-  };
-  const getMessageType = (message) => {
-    const normalizedMessage = normalizeMessageContent(message);
-    if (!normalizedMessage) return "text";
-    if (
-      normalizedMessage.reactionMessage ||
-      normalizedMessage.encReactionMessage
-    ) {
-      return "reaction";
-    }
-    if (
-      normalizedMessage.pollCreationMessage ||
-      normalizedMessage.pollCreationMessageV2 ||
-      normalizedMessage.pollCreationMessageV3 ||
-      normalizedMessage.pollUpdateMessage
-    ) {
-      return "poll";
-    }
-    if (normalizedMessage.eventMessage) {
-      return "event";
-    }
-    if (getMediaType(normalizedMessage) !== "") {
-      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 message.stickerMessage.isLottie
-        ? "1p_sticker"
-        : message.stickerMessage.isAvatar
-          ? "avatar_sticker"
-          : "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 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 kyyBail = new Dugong(waUploadToServer, relayMessage, config, sock);
-  const waitForMsgMediaUpdate = bindWaitForEvent(ev, "messages.media-update");
-  return {
-    ...sock,
-    getPrivacyTokens,
-    assertSessions,
-    relayMessage,
-    sendReceipt,
-    sendReceipts,
-    kyyBail,
-    readMessages,
-    refreshMediaConn,
-    waUploadToServer,
-    fetchPrivacySettings,
-    sendPeerDataOperationMessage,
-    createParticipantNodes,
-    getUSyncDevices,
-    messageRetryManager,
-    updateMemberLabel,
-    updateMediaMessage: async (message) => {
-      const content = assertMediaContent(message.message);
-      const mediaKey = content.mediaKey;
-      const meId = authState.creds.me.id;
-      const node = 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 = 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;
-    },
-    sendStatusMention: async (content, jids = []) => {
-      return await kyyBail.sendStatusWhatsApp(content, jids);
-    },
-    swgc: async (jid, content, options = {}) => {
-      if (!isJidGroup(jid)) {
-        throw new Boom("JID must be a group", { statusCode: 400 });
-      }
-      const storyContent = { groupStatusMessage: content };
-      return await kyyBail.handleGroupStory(storyContent, jid, null);
-    },
-    sendPreview: async (jid, preview, options = {}) => {
-      const extContent = {
-        text: preview.caption || preview.text || "",
-        matchedText: preview.matchedText || preview.url || "",
-        previewType: preview.previewType ?? 0,
-      };
-      if (preview.title) extContent.title = preview.title;
-      if (preview.description) extContent.description = preview.description;
-      if (preview.inviteLinkGroupTypeV2)
-        extContent.inviteLinkGroupTypeV2 = preview.inviteLinkGroupTypeV2;
-      if (preview.image) {
-        let imgBuf = preview.image;
-        if (typeof imgBuf === "string" && imgBuf.startsWith("http")) {
-          try {
-            const resp = await fetch(imgBuf);
-            imgBuf = Buffer.from(await resp.arrayBuffer());
-          } catch {}
+        else if (message.buttonsResponseMessage) {
+            return 'buttons_response';
         }
-        if (Buffer.isBuffer(imgBuf)) {
-          try {
-            const { imageMessage } = await prepareWAMessageMedia(
-              { image: imgBuf },
-              { upload: waUploadToServer, mediaTypeOverride: "thumbnail-link" },
-            );
-            if (imageMessage) {
-              extContent.jpegThumbnail = imageMessage.jpegThumbnail;
-              if (imageMessage.directPath)
-                extContent.thumbnailDirectPath = imageMessage.directPath;
-              if (imageMessage.mediaKey)
-                extContent.mediaKey = imageMessage.mediaKey;
-              if (imageMessage.mediaKeyTimestamp)
-                extContent.mediaKeyTimestamp = imageMessage.mediaKeyTimestamp;
-              if (imageMessage.fileSha256)
-                extContent.thumbnailSha256 = imageMessage.fileSha256;
-              if (imageMessage.fileEncSha256)
-                extContent.thumbnailEncSha256 = imageMessage.fileEncSha256;
-              if (imageMessage.width)
-                extContent.thumbnailWidth = imageMessage.width;
-              if (imageMessage.height)
-                extContent.thumbnailHeight = imageMessage.height;
-            }
-          } catch {
-            extContent.jpegThumbnail = imgBuf;
-          }
-        } else {
-          extContent.jpegThumbnail = imgBuf;
+        else if (message.orderMessage) {
+            return 'order';
         }
-      } else if (preview.jpegThumbnail) {
-        extContent.jpegThumbnail = preview.jpegThumbnail;
-      }
-      if (preview.thumbnailHeight)
-        extContent.thumbnailHeight = preview.thumbnailHeight;
-      if (preview.thumbnailWidth)
-        extContent.thumbnailWidth = preview.thumbnailWidth;
-      if (options.quoted) {
-        const participant = options.quoted.key.fromMe
-          ? authState.creds.me.id
-          : options.quoted.participant ||
-            options.quoted.key.participant ||
-            options.quoted.key.remoteJid;
-        extContent.contextInfo = {
-          stanzaId: options.quoted.key.id,
-          participant,
-          quotedMessage: options.quoted.message,
-        };
-      }
-      if (options.contextInfo) {
-        extContent.contextInfo = {
-          ...extContent.contextInfo,
-          ...options.contextInfo,
-        };
-      }
-      const messageId = generateMessageIDV2(sock.user?.id);
-      await relayMessage(
-        jid,
-        { extendedTextMessage: extContent },
-        { messageId },
-      );
-      return messageId;
-    },
-    // Aku tau kamu pasti bakalan nyari ini, tapi gak papa deh
-    // kyyBail — kyyinfinite
-    //  @Zann
-    sendTable: async (jid, title, headers, rows, quoted, options = {}) => {
-      const { message, messageId } = generateTableContent(
-        title,
-        headers,
-        rows,
-        quoted,
-        options,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendTableV2: async (jid, table, quoted, options = {}) => {
-      const { message, messageId } = generateTableContentV2(
-        table,
-        quoted,
-        options,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendList: async (jid, title, items, quoted, options = {}) => {
-      const { message, messageId } = generateListContent(
-        title,
-        items,
-        quoted,
-        options,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendCodeBlock: async (jid, code, quoted, options = {}) => {
-      const { message, messageId } = generateCodeBlockContent(
-        code,
-        quoted,
-        options,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendCodeBlockV2: async (jid, code, quoted, options = {}) => {
-      const { message, messageId } = generateCodeBlockContentV2(
-        code,
-        quoted,
-        options,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendLink: async (jid, text, links, quoted, options = {}) => {
-      const { message, messageId } = generateLinkContent(
-        text,
-        links,
-        quoted,
-        options,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendLinkV2: async (jid, text, links, quoted, options = {}) => {
-      const { message, messageId } = generateLinkContentV2(
-        text,
-        links,
-        quoted,
-        options,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendLatex: async (jid, quoted, options) => {
-      const { message, messageId } = generateLatexContent(quoted, options);
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendLatexImage: async (
-      jid,
-      quoted,
-      options,
-      renderLatexToPng,
-      uploadFn,
-    ) => {
-      const { message, messageId } = await generateLatexImageContent(
-        quoted,
-        options,
-        uploadFn,
-        renderLatexToPng,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendLatexInlineImage: async (
-      jid,
-      quoted,
-      options,
-      renderLatexToPng,
-      uploadFn,
-    ) => {
-      const { message, messageId } = await generateLatexInlineImageContent(
-        quoted,
-        options,
-        uploadFn,
-        renderLatexToPng,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    captureUnifiedResponse,
-    sendUnifiedResponse: async (jid, quoted, captured) => {
-      const { message, messageId } = generateUnifiedResponseContent(
-        quoted,
-        captured,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendRichMessage: async (jid, submessages, quoted, options = {}) => {
-      const { message, messageId } = generateRichMessageContent(
-        submessages,
-        quoted,
-      );
-      await relayMessage(jid, message, { messageId });
-      return { message, messageId };
-    },
-    sendMessage: async (jid, content, options = {}) => {
-      const userJid = authState.creds.me.id;
-      const { quoted } = options;
-      const messageType = kyyBail.detectType(content);
-      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 if (messageType) {
-        switch (messageType) {
-          case "PAYMENT": {
-            const paymentContent = await kyyBail.handlePayment(content, quoted);
-            return await relayMessage(jid, paymentContent, {
-              messageId: generateMessageIDV2(userJid),
-            });
-          }
-          case "PRODUCT": {
-            const productContent = await kyyBail.handleProduct(
-              content,
-              jid,
-              quoted,
-            );
-            const productMsg = await generateWAMessageFromContent(
-              jid,
-              productContent,
-              { quoted, userJid },
-            );
-            return await relayMessage(jid, productMsg.message, {
-              messageId: productMsg.key.id,
-            });
-          }
-          case "CAROUSEL": {
-            const carouselContent = await kyyBail.handleCarousel(
-              content,
-              jid,
-              quoted,
-            );
-            const carouselMsg = await generateWAMessageFromContent(
-              jid,
-              carouselContent,
-              { quoted, userJid },
-            );
-            return await relayMessage(jid, carouselMsg.message, {
-              messageId: carouselMsg.key.id,
-            });
-          }
-          case "INTERACTIVE": {
-            const interactiveContent = await kyyBail.handleInteractive(
-              content,
-              jid,
-              quoted,
-            );
-            const interactiveMsg = await generateWAMessageFromContent(
-              jid,
-              interactiveContent,
-              { quoted, userJid },
-            );
-            return await relayMessage(jid, interactiveMsg.message, {
-              messageId: interactiveMsg.key.id,
-            });
-          }
-          case "INTERACTIVE_BUTTONS": {
-            const ibContent = await kyyBail.handleInteractiveButtons(
-              content,
-              jid,
-              quoted,
-            );
-            const ibMsg = await generateWAMessageFromContent(jid, ibContent, {
-              quoted,
-              userJid,
-            });
-            return await relayMessage(jid, ibMsg.message, {
-              messageId: ibMsg.key.id,
-            });
-          }
-          case "ALBUM":
-            return await kyyBail.handleAlbum(content, jid, quoted);
-          case "EVENT":
-            return await kyyBail.handleEvent(content, jid, quoted);
-          case "POLL_RESULT":
-            return await kyyBail.handlePollResult(content, jid, quoted);
-          case "GROUP_STORY":
-            return await kyyBail.handleGroupStory(content, jid, quoted, options);
+        else if (message.productMessage) {
+            return 'product';
         }
-      } else {
-        let mediaHandle;
-        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: async (readStream, opts) => {
-            const up = await waUploadToServer(readStream, {
-              ...opts,
-              newsletter: isJidNewsletter(jid),
-            });
-            return up;
-          },
-          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 isAiMsg = "ai" in content && !!content.ai;
-        const additionalAttributes = {};
-        const additionalNodes = [];
-        if (isDeleteMsg) {
-          const fromMe = content.delete?.fromMe;
-          const isGroup = isJidGroup(content.delete?.remoteJid);
-          additionalAttributes.edit =
-            (isGroup && !fromMe) || isJidNewsletter(jid) ? "8" : "7";
-        } else if (isEditMsg) {
-          additionalAttributes.edit = isJidNewsletter(jid) ? "3" : "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" },
-          });
-        } else if (isAiMsg) {
-          additionalNodes.push({
-            tag: "bot",
-            attrs: { biz_bot: "1" },
-          });
+        else if (message.interactiveResponseMessage) {
+            return 'native_flow_response';
+        }
+        else if (message.groupInviteMessage) {
+            return 'url';
         }
-        await relayMessage(jid, fullMsg.message, {
-          messageId: fullMsg.key.id,
-          useCachedGroupMetadata: options.useCachedGroupMetadata,
-          additionalAttributes,
-          statusJidList: options.statusJidList,
-          additionalNodes: isAiMsg ? additionalNodes : options.additionalNodes,
+        return '';
+    };
+    const issuePrivacyTokens = async (jids, timestamp) => {
+        const t = (timestamp ?? 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'
+                        }
+                    }))
+                }
+            ]
         });
-        if (config.emitOwnEvents) {
-          process.nextTick(async () => {
-            await messageMutex.mutex(() => upsertMessage(fullMsg, "append"));
-          });
+        return result;
+    };
+    const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
+    const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+    registerSocketEndHandler(() => {
+        if (!config.userDevicesCache && userDevicesCache.close) {
+            userDevicesCache.close();
+        }
+        mediaConn = undefined;
+        if (messageRetryManager) {
+            messageRetryManager.clear();
         }
-        return fullMsg;
-      }
-    },
-  };
+    });
+    return {
+        ...sock,
+        userDevicesCache,
+        devicesMutex,
+        issuePrivacyTokens,
+        assertSessions,
+        relayMessage,
+        sendReceipt,
+        sendReceipts,
+        readMessages,
+        refreshMediaConn,
+        // Function (not getter) so the spread in chats.ts preserves the live closure binding.
+        getMediaHost: () => mediaHost,
+        waUploadToServer,
+        fetchPrivacySettings,
+        sendPeerDataOperationMessage,
+        createParticipantNodes,
+        getUSyncDevices,
+        messageRetryManager,
+        updateMemberLabel,
+        updateMediaMessage: async (message) => {
+            const content = assertMediaContent(message.message);
+            const mediaKey = content.mediaKey;
+            const meId = authState.creds.me.id;
+            const node = 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 = 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, mediaHost);
+                                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
+                    }),
+                    //TODO: CACHE
+                    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 = [];
+                // required for delete
+                if (isDeleteMsg) {
+                    // if the chat is a group, and I am not the author, then delete the message as an admin
+                    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(async () => {
+                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                    });
+                }
+                return fullMsg;
+            }
+        }
+    };
 };
-//# sourceMappingURL=messages-send.js.map
+//# sourceMappingURL=messages-send.js.map