zapo-js 1.6.2 → 1.7.1

package/dist/client/coordinators/WaMessageDispatchCoordinator.d.ts

@@ -17,11 +17,13 @@ import type { SenderKeyManager } from '../../signal/group/SenderKeyManager';
 import type { SignalSessionResolver } from '../../signal/session/resolver';
 import type { SignalProtocol } from '../../signal/session/SignalProtocol';
 import type { SignalAddress } from '../../signal/types';
+import type { WaChatMetadataStore } from '../../store/contracts/chat-metadata.store';
 import type { WaDeviceListStore } from '../../store/contracts/device-list.store';
 import type { WaIdentityStore } from '../../store/contracts/identity.store';
 import type { WaMessageSecretStore } from '../../store/contracts/message-secret.store';
 import type { WaSessionStore } from '../../store/contracts/session.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { WaThreadStore } from '../../store/contracts/thread.store';
 import type { BinaryNode } from '../../transport/types';
 import type { ServerClock } from '../../util/clock';
 interface WaMessageDispatchCoordinatorOptions {
@@ -45,6 +47,8 @@ interface WaMessageDispatchCoordinatorOptions {
     readonly sessionStore: WaSessionStore;
     readonly identityStore: WaIdentityStore;
     readonly deviceListStore: WaDeviceListStore;
+    readonly threadStore: WaThreadStore;
+    readonly chatMetadataStore: WaChatMetadataStore;
     readonly signalDeviceSync: SignalDeviceSyncApi;
     readonly messageSecretStore: WaMessageSecretStore;
     /**
@@ -66,6 +70,32 @@ interface WaMessageDispatchCoordinatorOptions {
     readonly mobileMessageIdFormat?: () => boolean;
     readonly serverClock: ServerClock;
 }
+/** Membership split behind a group-history share, in the group's addressing mode. */
+export interface WaGroupHistoryAudience {
+    /** Members the bundle is addressed to. */
+    readonly historyReceivers: readonly string[];
+    /** Members in the group who are not receiving it. */
+    readonly nonHistoryReceivers: readonly string[];
+    /** Requested JIDs that are not current members of the group. */
+    readonly unknownJids: readonly string[];
+    /** Whether the caller asked to share with this account itself. */
+    readonly requestedSelf: boolean;
+    readonly addressingMode: 'pn' | 'lid';
+}
+/**
+ * Narrows a group's participant list to the members a group-history bundle is
+ * addressed to, plus the sender so its own devices keep a copy. Receivers are
+ * intersected with the live participant list, so a stale receiver entry cannot
+ * pull a non-member into the fanout. Any other message keeps the full list.
+ *
+ * Receivers must be written in the group's addressing mode - a PN entry for a
+ * LID-addressed group does not match and is reported through `onDropped`.
+ *
+ * @throws when no receiver matches a current member. Sending to the sender's
+ * own devices alone counts as no match: it would look like a delivered share
+ * while nobody received anything.
+ */
+export declare function restrictGroupHistoryTargets(message: Proto.IMessage, participantUserJids: readonly string[], senderJid: string, onDropped?: (droppedJids: readonly string[], totalExpected: number) => void): readonly string[];
 export declare class WaMessageDispatchCoordinator {
     private readonly deps;
     private readonly mobileMessageIdFormat;
@@ -74,6 +104,24 @@ export declare class WaMessageDispatchCoordinator {
     private readonly privacyTokenDedup;
     private readonly distributionDedup;
     constructor(options: WaMessageDispatchCoordinatorOptions);
+    /**
+     * Per-chat disappearing settings from the cache, falling back to the
+     * durable thread record on a cold miss and warming the cache with it. A
+     * chat with no disappearing mode is cached as expiration `0` rather than
+     * left absent, so the archive is not re-read on every send to it; the
+     * incoming writers overwrite that entry the moment the chat turns it on.
+     * A failing archive degrades the send to "no ephemeral fields" instead of
+     * rejecting it - the store is opt-in persistence, not a send dependency.
+     */
+    private resolveChatMetadata;
+    /**
+     * Disappearing-message fields for a send into a chat with the mode on, or
+     * `{}` when nothing resolves. Both chat kinds report initiator
+     * `CHANGED_IN_CHAT` when nothing more specific is stored; the trigger comes
+     * from the group metadata for a group and defaults to `CHAT_SETTING` for
+     * 1:1, and is omitted when a group reports none.
+     */
+    private resolveChatEphemeral;
     publishMessageNode(node: BinaryNode, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
     publishEncryptedMessage(input: WaEncryptedMessageInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
     publishSignalMessage(input: WaSignalMessagePublishInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
@@ -119,6 +167,22 @@ export declare class WaMessageDispatchCoordinator {
     requestAppStateSyncKeys(keyIds: readonly Uint8Array[]): Promise<readonly string[]>;
     sendAppStateSyncKeyShare(toDeviceJid: string, keys: readonly WaAppStateSyncKey[], missingKeyIds?: readonly Uint8Array[]): Promise<void>;
     mutateGroupMetadataCacheFromGroupEvent(event: WaGroupEvent): Promise<void>;
+    /**
+     * Splits a group's members into the ones a history bundle is being shared
+     * with and the rest, normalizing everything to the group's addressing mode
+     * so the receiver list written into the proto matches what the fanout can
+     * actually resolve. This account is excluded from both lists.
+     *
+     * Requested JIDs that are not current members come back in `unknownJids`
+     * instead of being silently dropped - sharing history with a non-member is
+     * a caller mistake worth surfacing.
+     */
+    resolveGroupHistoryAudience(groupJid: string, requestedJids: readonly string[]): Promise<WaGroupHistoryAudience>;
+    /**
+     * A group-history bundle goes to the members named in `historyReceivers`
+     * rather than to the whole group, so it takes the per-device direct fanout
+     * instead of the group sender key.
+     */
     private shouldUseGroupDirectPath;
     private publishGroupDirectMessage;
     private buildBotSidecarParticipant;

package/dist/client/coordinators/WaMessageDispatchCoordinator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageDispatchCoordinator = void 0;
+exports.restrictGroupHistoryTargets = restrictGroupHistoryTargets;
 const _crypto_1 = require("../../crypto");
 const primitives_1 = require("../../crypto/core/primitives");
 const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
@@ -20,6 +21,58 @@ const binary_1 = require("../../transport/binary");
 const message_1 = require("../../transport/node/builders/message");
 const bytes_1 = require("../../util/bytes");
 const primitives_2 = require("../../util/primitives");
+/**
+ * Members a group-history bundle is addressed to. Empty for every other
+ * message, which is what keeps the restricted fanout scoped to bundles.
+ */
+function resolveGroupHistoryReceivers(message) {
+    const metadata = (0, content_1.unwrapMessage)(message).messageHistoryBundle?.messageHistoryMetadata;
+    return metadata?.historyReceivers ?? [];
+}
+/**
+ * Narrows a group's participant list to the members a group-history bundle is
+ * addressed to, plus the sender so its own devices keep a copy. Receivers are
+ * intersected with the live participant list, so a stale receiver entry cannot
+ * pull a non-member into the fanout. Any other message keeps the full list.
+ *
+ * Receivers must be written in the group's addressing mode - a PN entry for a
+ * LID-addressed group does not match and is reported through `onDropped`.
+ *
+ * @throws when no receiver matches a current member. Sending to the sender's
+ * own devices alone counts as no match: it would look like a delivered share
+ * while nobody received anything.
+ */
+function restrictGroupHistoryTargets(message, participantUserJids, senderJid, onDropped) {
+    const receivers = resolveGroupHistoryReceivers(message);
+    if (receivers.length === 0) {
+        return participantUserJids;
+    }
+    const pending = new Set();
+    for (let index = 0; index < receivers.length; index += 1) {
+        pending.add((0, jid_1.toUserJid)(receivers[index]));
+    }
+    const senderUserJid = (0, jid_1.toUserJid)(senderJid);
+    const targets = [];
+    let matchedReceivers = 0;
+    for (let index = 0; index < participantUserJids.length; index += 1) {
+        const participant = participantUserJids[index];
+        const participantUserJid = (0, jid_1.toUserJid)(participant);
+        if (pending.delete(participantUserJid)) {
+            matchedReceivers += 1;
+            targets[targets.length] = participant;
+        }
+        else if (participantUserJid === senderUserJid) {
+            targets[targets.length] = participant;
+        }
+    }
+    if (pending.size > 0 && onDropped) {
+        onDropped([...pending], receivers.length);
+    }
+    if (matchedReceivers === 0) {
+        throw new Error('group history bundle resolved no receivers in the group');
+    }
+    return targets;
+}
 class WaMessageDispatchCoordinator {
     constructor(options) {
         this.icdcDedup = new PromiseDedup_1.PromiseDedup();
@@ -29,6 +82,82 @@ class WaMessageDispatchCoordinator {
         this.mobileMessageIdFormat = options.mobileMessageIdFormat ?? (() => false);
         this.serverClock = options.serverClock;
     }
+    /**
+     * Per-chat disappearing settings from the cache, falling back to the
+     * durable thread record on a cold miss and warming the cache with it. A
+     * chat with no disappearing mode is cached as expiration `0` rather than
+     * left absent, so the archive is not re-read on every send to it; the
+     * incoming writers overwrite that entry the moment the chat turns it on.
+     * A failing archive degrades the send to "no ephemeral fields" instead of
+     * rejecting it - the store is opt-in persistence, not a send dependency.
+     */
+    async resolveChatMetadata(chatJid) {
+        try {
+            const cached = await this.deps.chatMetadataStore.getChatMetadata(chatJid);
+            if (cached) {
+                return cached;
+            }
+            const thread = await this.deps.threadStore.getByJid(chatJid);
+            const expiration = thread?.ephemeralExpiration ?? 0;
+            const settingTimestamp = expiration > 0 ? thread?.ephemeralSettingTimestamp : undefined;
+            const snapshot = {
+                chatJid,
+                ephemeralExpiration: expiration,
+                ...(settingTimestamp !== undefined
+                    ? { ephemeralSettingTimestamp: settingTimestamp }
+                    : {}),
+                updatedAtMs: Date.now()
+            };
+            await this.deps.chatMetadataStore.upsertChatMetadata(snapshot);
+            return snapshot;
+        }
+        catch (error) {
+            this.deps.logger.debug('chat metadata lookup failed, sending without ephemeral fields', {
+                jid: chatJid,
+                message: (0, primitives_2.toError)(error).message
+            });
+            return null;
+        }
+    }
+    /**
+     * Disappearing-message fields for a send into a chat with the mode on, or
+     * `{}` when nothing resolves. Both chat kinds report initiator
+     * `CHANGED_IN_CHAT` when nothing more specific is stored; the trigger comes
+     * from the group metadata for a group and defaults to `CHAT_SETTING` for
+     * 1:1, and is omitted when a group reports none.
+     */
+    async resolveChatEphemeral(recipientJid) {
+        if ((0, jid_1.isGroupJid)(recipientJid)) {
+            const settings = await this.deps.groupMetadataCache.resolveEphemeralSettings(recipientJid);
+            if (!settings) {
+                return {};
+            }
+            return {
+                expirationSeconds: settings.expirationSeconds,
+                disappearingModeInitiator: _proto_1.proto.DisappearingMode.Initiator.CHANGED_IN_CHAT,
+                ...(settings.trigger !== undefined
+                    ? {
+                        disappearingModeTrigger: settings.trigger
+                    }
+                    : {})
+            };
+        }
+        const chat = await this.resolveChatMetadata(recipientJid);
+        const expiration = chat?.ephemeralExpiration;
+        if (expiration === undefined || expiration <= 0) {
+            return {};
+        }
+        const stored = chat?.ephemeralSettingTimestamp;
+        const settingTimestamp = stored !== undefined ? (0, constants_1.normalizeEphemeralSettingSeconds)(stored) : undefined;
+        return {
+            expirationSeconds: expiration,
+            disappearingModeInitiator: _proto_1.proto.DisappearingMode.Initiator.CHANGED_IN_CHAT,
+            disappearingModeTrigger: _proto_1.proto.DisappearingMode.Trigger.CHAT_SETTING,
+            ...(settingTimestamp !== undefined
+                ? { ephemeralSettingTimestamp: settingTimestamp }
+                : {})
+        };
+    }
     async publishMessageNode(node, options = {}) {
         this.deps.logger.trace('wa client publish message node', {
             tag: node.tag,
@@ -149,17 +278,34 @@ class WaMessageDispatchCoordinator {
                 this.withResolvedMessageId(options)
             ]);
         }
+        const isGroupRecipient = (0, jid_1.isGroupJid)(recipientJid);
+        const directRecipientJid = isGroupRecipient
+            ? recipientJid
+            : await this.resolveDirectRecipientLid((0, jid_1.toUserJid)(recipientJid));
         let optionsCtx = options.contextInfo;
         if (options.expirationSeconds !== undefined) {
             optionsCtx = { ...optionsCtx, expirationSeconds: options.expirationSeconds };
         }
-        if ((0, jid_1.isGroupJid)(recipientJid) &&
-            optionsCtx?.expirationSeconds === undefined &&
-            !options.disableGroupEphemeralAutoInject) {
-            const cachedEphemeral = await this.deps.groupMetadataCache.resolveEphemeral(recipientJid);
-            if (cachedEphemeral !== null && cachedEphemeral > 0) {
-                optionsCtx = { ...optionsCtx, expirationSeconds: cachedEphemeral };
-            }
+        if (options.ephemeralSettingTimestamp !== undefined) {
+            optionsCtx = {
+                ...optionsCtx,
+                ephemeralSettingTimestamp: options.ephemeralSettingTimestamp
+            };
+        }
+        if (options.disappearingModeTrigger !== undefined) {
+            optionsCtx = {
+                ...optionsCtx,
+                disappearingModeTrigger: options.disappearingModeTrigger
+            };
+        }
+        const autoInjectDisabled = isGroupRecipient
+            ? options.disableGroupEphemeralAutoInject
+            : options.disableDirectEphemeralAutoInject;
+        if (optionsCtx?.expirationSeconds === undefined && !autoInjectDisabled) {
+            optionsCtx = {
+                ...(await this.resolveChatEphemeral(directRecipientJid)),
+                ...optionsCtx
+            };
         }
         const ctx = (0, context_info_1.resolveSendContextInfo)({
             contentLevel: pickContentContextInfo(content),
@@ -252,17 +398,16 @@ class WaMessageDispatchCoordinator {
         ]);
         const messageWithIcdc = (0, icdc_1.injectDeviceListMetadata)(messageWithSecret, senderIcdc, recipientIcdc);
         const plaintext = await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode(messageWithIcdc).finish());
-        const buttonAddonKind = (0, content_1.resolveButtonAddonKind)(messageWithIcdc);
+        const outboundAttrs = (0, content_1.resolveOutboundMessageAttrs)(messageWithIcdc);
+        const buttonAddonKind = outboundAttrs.buttonAddonKind;
         const buttonAddonNode = buttonAddonKind ? (0, message_1.buildButtonAddonNode)(buttonAddonKind) : undefined;
         // when a <biz> companion is attached the stanza must advertise type=text and
         // omit enc.mediatype; sending type=media + mediatype=list/button alongside the
         // companion is rejected by the server as SMAX_INVALID (479).
-        const type = buttonAddonKind ? 'text' : (0, content_1.resolveMessageTypeAttr)(messageWithIcdc);
-        const edit = (0, content_1.resolveEditAttr)(messageWithIcdc) ?? undefined;
-        const mediatype = buttonAddonKind
-            ? undefined
-            : ((0, content_1.resolveEncMediaType)(messageWithIcdc) ?? undefined);
-        const metaAttrs = (0, content_1.resolveMetaAttrs)(messageWithIcdc);
+        const type = buttonAddonKind ? 'text' : outboundAttrs.typeAttr;
+        const edit = outboundAttrs.edit ?? undefined;
+        const mediatype = buttonAddonKind ? undefined : (outboundAttrs.mediatype ?? undefined);
+        const metaAttrs = outboundAttrs.metaAttrs;
         const metaNode = metaAttrs ? (0, message_1.buildMetaNode)(metaAttrs) : undefined;
         const customNodes = [];
         if (metaNode)
@@ -274,7 +419,7 @@ class WaMessageDispatchCoordinator {
                 customNodes.push(node);
             }
         }
-        const decryptFail = (0, content_1.resolveDecryptFailAttr)(messageWithIcdc);
+        const decryptFail = outboundAttrs.decryptFail;
         const envelope = {
             message: messageWithIcdc,
             plaintext,
@@ -285,9 +430,6 @@ class WaMessageDispatchCoordinator {
             customNodes: customNodes.length > 0 ? customNodes : undefined,
             sendOptions
         };
-        const directRecipientJid = isGroup
-            ? recipientJid
-            : await this.resolveDirectRecipientLid((0, jid_1.toUserJid)(recipientJid));
         const peerRecipientPn = isGroup
             ? undefined
             : await this.resolvePeerRecipientPn((0, jid_1.toUserJid)(recipientJid), directRecipientJid);
@@ -397,7 +539,7 @@ class WaMessageDispatchCoordinator {
             replayStatusSetting: statusSetting,
             // Bare `<to jid=user>` ack hints route the skmsg through primary
             // devices that already hold the sender key.
-            customize: async ({ fanoutDeviceJids, distributionParticipants, messageWithSecret, sendOptions }) => {
+            customize: ({ fanoutDeviceJids, distributionParticipants, messageWithSecret, sendOptions }) => {
                 const distributedAddressKeys = new Set();
                 for (let i = 0; i < distributionParticipants.length; i += 1) {
                     distributedAddressKeys.add((0, jid_1.signalAddressKey)(distributionParticipants[i].address));
@@ -417,7 +559,7 @@ class WaMessageDispatchCoordinator {
                     seenAck.add(userJid);
                     ackHints.push({ jid: userJid });
                 }
-                const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
+                const reportingArtifacts = this.tryBuildReportingTokenArtifacts({
                     message: messageWithSecret,
                     stanzaId: sendOptions.id,
                     senderUserJid: (0, jid_1.toUserJid)(senderJid),
@@ -495,14 +637,15 @@ class WaMessageDispatchCoordinator {
                 participants.push(entry);
             }
         }
+        const outboundAttrs = (0, content_1.resolveOutboundMessageAttrs)(messageWithSecret);
         const messageNode = (0, message_1.buildGroupSenderKeyMessageNode)({
             to: input.groupJid,
-            type: (0, content_1.resolveMessageTypeAttr)(messageWithSecret),
+            type: outboundAttrs.typeAttr,
             id: sendOptions.id,
             phash: extras.phash,
-            edit: (0, content_1.resolveEditAttr)(messageWithSecret) ?? undefined,
-            mediatype: (0, content_1.resolveEncMediaType)(messageWithSecret) ?? undefined,
-            decryptFail: (0, content_1.resolveDecryptFailAttr)(messageWithSecret),
+            edit: outboundAttrs.edit ?? undefined,
+            mediatype: outboundAttrs.mediatype ?? undefined,
+            decryptFail: outboundAttrs.decryptFail,
             groupCiphertext: groupCiphertext.ciphertext,
             participants,
             deviceIdentity: shouldAttachDeviceIdentity
@@ -550,9 +693,59 @@ class WaMessageDispatchCoordinator {
     async mutateGroupMetadataCacheFromGroupEvent(event) {
         await this.deps.groupMetadataCache.mutateFromGroupEvent(event);
     }
-    // noop for now
+    /**
+     * Splits a group's members into the ones a history bundle is being shared
+     * with and the rest, normalizing everything to the group's addressing mode
+     * so the receiver list written into the proto matches what the fanout can
+     * actually resolve. This account is excluded from both lists.
+     *
+     * Requested JIDs that are not current members come back in `unknownJids`
+     * instead of being silently dropped - sharing history with a non-member is
+     * a caller mistake worth surfacing.
+     */
+    async resolveGroupHistoryAudience(groupJid, requestedJids) {
+        const participants = await this.deps.groupMetadataCache.resolveParticipantUsers(groupJid);
+        const meJid = this.requireCurrentMeJid('shareGroupHistory');
+        const addressingMode = this.resolveGroupAddressingMode(participants, groupJid);
+        const meUserJid = (0, jid_1.toUserJid)(this.resolveSenderForAddressingMode(addressingMode, meJid));
+        const pending = new Set();
+        for (let index = 0; index < requestedJids.length; index += 1) {
+            pending.add((0, jid_1.toUserJid)((0, jid_1.normalizeRecipientJid)(requestedJids[index])));
+        }
+        const historyReceivers = [];
+        const nonHistoryReceivers = [];
+        for (let index = 0; index < participants.length; index += 1) {
+            const participantUserJid = (0, jid_1.toUserJid)(participants[index]);
+            if (participantUserJid === meUserJid) {
+                continue;
+            }
+            if (pending.delete(participantUserJid)) {
+                historyReceivers[historyReceivers.length] = participantUserJid;
+            }
+            else {
+                nonHistoryReceivers[nonHistoryReceivers.length] = participantUserJid;
+            }
+        }
+        const requestedSelf = pending.delete(meUserJid);
+        const unknownJids = [];
+        for (const jid of pending) {
+            unknownJids[unknownJids.length] = jid;
+        }
+        return {
+            historyReceivers,
+            nonHistoryReceivers,
+            unknownJids,
+            requestedSelf,
+            addressingMode
+        };
+    }
+    /**
+     * A group-history bundle goes to the members named in `historyReceivers`
+     * rather than to the whole group, so it takes the per-device direct fanout
+     * instead of the group sender key.
+     */
     shouldUseGroupDirectPath(message) {
-        return false;
+        return resolveGroupHistoryReceivers(message).length > 0;
     }
     async publishGroupDirectMessage(groupJid, envelope, retryContext = {}) {
         const { message, plaintext, type, edit, mediatype, sendOptions } = envelope;
@@ -562,8 +755,16 @@ class WaMessageDispatchCoordinator {
             : await this.deps.groupMetadataCache.resolveParticipantUsers(groupJid);
         const addressingMode = retryContext.forceAddressingMode ??
             this.resolveGroupAddressingMode(participantUserJids, groupJid);
-        const senderForPhash = this.resolveSenderForAddressingMode(addressingMode, meJid);
-        const fanoutDeviceJids = await this.deps.fanoutResolver.resolveGroupParticipantDeviceJids(participantUserJids);
+        const senderJid = this.resolveSenderForAddressingMode(addressingMode, meJid);
+        const targetUserJids = restrictGroupHistoryTargets(message, participantUserJids, senderJid, (droppedJids, totalExpected) => {
+            this.deps.logger.warn('group history receivers missing from the participant list', {
+                groupJid,
+                droppedCount: droppedJids.length,
+                totalExpected,
+                sample: droppedJids.slice(0, 3)
+            });
+        });
+        const fanoutDeviceJids = await this.deps.fanoutResolver.resolveGroupParticipantDeviceJids(targetUserJids);
         if (fanoutDeviceJids.length === 0) {
             throw new Error('group direct send resolved no target devices');
         }
@@ -618,22 +819,11 @@ class WaMessageDispatchCoordinator {
                 break;
             }
         }
-        const phashTargets = new Array(resolvedFanoutTargets.length + 1);
-        let phashTargetCount = 0;
-        for (let index = 0; index < resolvedFanoutTargets.length; index += 1) {
-            const candidate = resolvedFanoutTargets[index].jid;
-            if ((0, jid_1.isHostedDeviceJid)(candidate))
-                continue;
-            phashTargets[phashTargetCount] = candidate;
-            phashTargetCount += 1;
-        }
-        phashTargets[phashTargetCount] = senderForPhash;
-        phashTargets.length = phashTargetCount + 1;
-        const localPhash = (0, phash_1.computePhashV2)(phashTargets);
-        const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
+        const reportingArtifacts = this.tryBuildReportingTokenArtifacts({
             message,
+            messageBytes: (0, padding_1.unpadPkcs7)(plaintext),
             stanzaId: sendOptions.id,
-            senderUserJid: (0, jid_1.toUserJid)(senderForPhash),
+            senderUserJid: (0, jid_1.toUserJid)(senderJid),
             remoteJid: groupJid,
             context: 'group_direct'
         });
@@ -645,7 +835,6 @@ class WaMessageDispatchCoordinator {
             type,
             id: sendOptions.id,
             edit,
-            phash: localPhash,
             addressingMode,
             participants,
             deviceIdentity: shouldAttachDeviceIdentity
@@ -671,7 +860,7 @@ class WaMessageDispatchCoordinator {
         const ackError = result.ack.error;
         const serverPhash = result.ack.phash;
         const serverAddressingMode = result.ack.addressingMode;
-        const hasPhashMismatch = !!serverPhash && serverPhash !== localPhash;
+        const hasPhashMismatch = !!serverPhash;
         const hasAddressingMismatch = !!serverAddressingMode && serverAddressingMode !== addressingMode;
         const hasAddressingError = ackError === constants_1.WA_NACK_REASONS.STALE_GROUP_ADDRESSING_MODE;
         if (!retryContext.retried &&
@@ -679,7 +868,6 @@ class WaMessageDispatchCoordinator {
             this.deps.logger.warn('group direct publish acknowledged with mismatch metadata', {
                 id: result.id,
                 groupJid,
-                localPhash,
                 serverPhash,
                 localAddressingMode: addressingMode,
                 serverAddressingMode,
@@ -788,8 +976,9 @@ class WaMessageDispatchCoordinator {
         phashTargets[phashTargetCount] = senderJid;
         phashTargets.length = phashTargetCount + 1;
         const localPhash = (0, phash_1.computePhashV2)(phashTargets);
-        const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
+        const reportingArtifacts = this.tryBuildReportingTokenArtifacts({
             message,
+            messageBytes: (0, padding_1.unpadPkcs7)(plaintext),
             stanzaId: sendOptions.id,
             senderUserJid: (0, jid_1.toUserJid)(senderJid),
             remoteJid: groupJid,
@@ -901,9 +1090,6 @@ class WaMessageDispatchCoordinator {
         return (0, jid_1.normalizeDeviceJid)(meJid);
     }
     async encryptGroupDistributionParticipants(groupJid, senderKeyId, senderKeyDistributionMessage, participantUserJids) {
-        const distributionPayload = await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode({
-            senderKeyDistributionMessage
-        }).finish());
         const fanoutDeviceJids = await this.deps.fanoutResolver.resolveGroupParticipantDeviceJids(participantUserJids);
         if (fanoutDeviceJids.length === 0) {
             return {
@@ -911,13 +1097,9 @@ class WaMessageDispatchCoordinator {
                 distributionParticipants: []
             };
         }
-        const fanoutTargetsByAddressKey = new Map();
         const fanoutAddresses = new Array(fanoutDeviceJids.length);
         for (let index = 0; index < fanoutDeviceJids.length; index += 1) {
-            const jid = fanoutDeviceJids[index];
-            const address = (0, jid_1.parseSignalAddressFromJid)(jid);
-            fanoutAddresses[index] = address;
-            fanoutTargetsByAddressKey.set((0, jid_1.signalAddressKey)(address), { jid, address });
+            fanoutAddresses[index] = (0, jid_1.parseSignalAddressFromJid)(fanoutDeviceJids[index]);
         }
         const pendingAddresses = await this.deps.senderKeyManager.filterParticipantsNeedingDistribution(groupJid, senderKeyId, fanoutAddresses);
         if (pendingAddresses.length === 0) {
@@ -926,6 +1108,14 @@ class WaMessageDispatchCoordinator {
                 distributionParticipants: []
             };
         }
+        const fanoutTargetsByAddressKey = new Map();
+        for (let index = 0; index < fanoutAddresses.length; index += 1) {
+            const address = fanoutAddresses[index];
+            fanoutTargetsByAddressKey.set((0, jid_1.signalAddressKey)(address), {
+                jid: fanoutDeviceJids[index],
+                address
+            });
+        }
         const pendingAddressKeys = new Set();
         const pendingTargets = [];
         for (let index = 0; index < pendingAddresses.length; index += 1) {
@@ -985,6 +1175,9 @@ class WaMessageDispatchCoordinator {
                 distributionParticipants: []
             };
         }
+        const distributionPayload = await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode({
+            senderKeyDistributionMessage
+        }).finish());
         const distributionEncryptRequests = new Array(availableTargets.length);
         for (let index = 0; index < availableTargets.length; index += 1) {
             const target = availableTargets[index];
@@ -1137,8 +1330,9 @@ class WaMessageDispatchCoordinator {
         const deviceIdentity = shouldAttachDeviceIdentity
             ? this.getEncodedSignedDeviceIdentity()
             : undefined;
-        const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
+        const reportingArtifacts = this.tryBuildReportingTokenArtifacts({
             message,
+            messageBytes: (0, padding_1.unpadPkcs7)(plaintext),
             stanzaId: sendOptions.id,
             senderUserJid: meUserJid,
             remoteJid: recipientUserJid,
@@ -1241,13 +1435,14 @@ class WaMessageDispatchCoordinator {
             return `3EB0${(0, bytes_1.bytesToHex)(await (0, _crypto_1.randomBytesAsync)(8)).toUpperCase()}`;
         }
     }
-    async tryBuildReportingTokenArtifacts(input) {
+    tryBuildReportingTokenArtifacts(input) {
         if (!input.stanzaId) {
             return null;
         }
         try {
-            return await (0, reporting_token_1.buildReportingTokenArtifacts)({
+            return (0, reporting_token_1.buildReportingTokenArtifacts)({
                 message: input.message,
+                messageBytes: input.messageBytes,
                 stanzaId: input.stanzaId,
                 senderUserJid: input.senderUserJid,
                 remoteJid: input.remoteJid