zapo-js 0.1.2 → 0.2.0

package/dist/client/coordinators/WaMessageDispatchCoordinator.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageDispatchCoordinator = void 0;
 const _crypto_1 = require("../../crypto/index.js");
+const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
 const _message_1 = require("../../message/index.js");
 const content_1 = require("../../message/content");
 const device_sent_1 = require("../../message/device-sent");
+const icdc_1 = require("../../message/icdc");
 const padding_1 = require("../../message/padding");
 const phash_1 = require("../../message/phash");
 const reporting_token_1 = require("../../message/reporting-token");
@@ -18,6 +20,9 @@ const bytes_1 = require("../../util/bytes");
 const primitives_1 = require("../../util/primitives");
 class WaMessageDispatchCoordinator {
     constructor(options) {
+        this.icdcDedup = new PromiseDedup_1.PromiseDedup();
+        this.privacyTokenDedup = new PromiseDedup_1.PromiseDedup();
+        this.distributionDedup = new PromiseDedup_1.PromiseDedup();
         this.logger = options.logger;
         this.messageClient = options.messageClient;
         this.retryTracker = options.retryTracker;
@@ -28,9 +33,13 @@ class WaMessageDispatchCoordinator {
         this.buildMessageContent = options.buildMessageContent;
         this.senderKeyManager = options.senderKeyManager;
         this.signalProtocol = options.signalProtocol;
+        this.signalStore = options.signalStore;
+        this.deviceListStore = options.deviceListStore;
         this.getCurrentMeJid = options.getCurrentMeJid;
         this.getCurrentMeLid = options.getCurrentMeLid;
         this.getCurrentSignedIdentity = options.getCurrentSignedIdentity;
+        this.resolvePrivacyTokenNode = options.resolvePrivacyTokenNode;
+        this.onDirectMessageSent = options.onDirectMessageSent;
     }
     async publishMessageNode(node, options = {}) {
         this.logger.debug('wa client publish message node', {
@@ -71,7 +80,8 @@ class WaMessageDispatchCoordinator {
             toJid: input.to,
             type: input.type ?? 'text',
             replayPayload,
-            participantJid: input.participant
+            participantJid: input.participant,
+            eligibleRequesterDeviceJids: [input.to]
         }, async () => this.messageClient.publishEncrypted(input, options));
     }
     async publishSignalMessage(input, options = {}) {
@@ -101,7 +111,8 @@ class WaMessageDispatchCoordinator {
             toJid: input.to,
             type: messageType,
             replayPayload,
-            participantJid: input.participant
+            participantJid: input.participant,
+            eligibleRequesterDeviceJids: [input.to]
         }, async () => this.messageClient.publishEncrypted({
             to: input.to,
             encType: encrypted.type,
@@ -121,16 +132,32 @@ class WaMessageDispatchCoordinator {
             this.withResolvedMessageId(options)
         ]);
         const messageWithSecret = await (0, _message_1.ensureMessageSecret)(message);
-        const plaintext = await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode(messageWithSecret).finish());
-        const type = (0, content_1.resolveMessageTypeAttr)(messageWithSecret);
-        if ((0, jid_1.isGroupJid)(recipientJid)) {
-            if (this.shouldUseGroupDirectPath(messageWithSecret)) {
-                return this.publishGroupDirectMessage(recipientJid, messageWithSecret, plaintext, type, sendOptions);
+        const meJid = this.getCurrentMeJid();
+        const regInfo = meJid ? await this.signalStore.getRegistrationInfo() : null;
+        const localPubKey = regInfo?.identityKeyPair.pubKey;
+        const meParsed = meJid ? (0, jid_1.parseJidFull)(meJid) : undefined;
+        const meUserJid = meParsed?.userJid;
+        const localIdentity = meParsed && localPubKey ? { address: meParsed.address, pubKey: localPubKey } : undefined;
+        const isGroup = (0, jid_1.isGroupJid)(recipientJid);
+        const [senderIcdc, recipientIcdc] = await Promise.all([
+            meUserJid ? this.resolveUserIcdc(meUserJid, localIdentity) : null,
+            !isGroup ? this.resolveUserIcdc((0, jid_1.toUserJid)(recipientJid)) : null
+        ]);
+        const messageWithIcdc = (0, icdc_1.injectDeviceListMetadata)(messageWithSecret, senderIcdc, recipientIcdc);
+        const plaintext = await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode(messageWithIcdc).finish());
+        const type = (0, content_1.resolveMessageTypeAttr)(messageWithIcdc);
+        const edit = (0, content_1.resolveEditAttr)(messageWithIcdc, sendOptions.subtype) ?? undefined;
+        const mediatype = (0, content_1.resolveEncMediaType)(messageWithIcdc) ?? undefined;
+        const metaAttrs = (0, content_1.resolveMetaAttrs)(messageWithIcdc);
+        const metaNode = metaAttrs ? (0, message_1.buildMetaNode)(metaAttrs) : undefined;
+        if (isGroup) {
+            if (this.shouldUseGroupDirectPath(messageWithIcdc)) {
+                return this.publishGroupDirectMessage(recipientJid, messageWithIcdc, plaintext, type, sendOptions, {}, edit, mediatype, metaNode);
             }
-            return this.publishGroupSenderKeyMessage(recipientJid, messageWithSecret, plaintext, type, sendOptions);
+            return this.publishGroupSenderKeyMessage(recipientJid, messageWithIcdc, plaintext, type, sendOptions, {}, edit, mediatype, metaNode);
         }
         const directRecipientJid = (0, jid_1.toUserJid)(recipientJid);
-        return this.publishDirectSignalMessageWithFanout(directRecipientJid, messageWithSecret, plaintext, type, sendOptions);
+        return this.publishDirectSignalMessageWithFanout(directRecipientJid, messageWithIcdc, plaintext, type, sendOptions, edit, mediatype, metaNode);
     }
     async syncSignalSession(jid, reasonIdentity = false) {
         const address = (0, jid_1.parseSignalAddressFromJid)(jid);
@@ -159,7 +186,7 @@ class WaMessageDispatchCoordinator {
         }
         return message.keepInChatMessage?.keepType === _proto_1.proto.KeepType.UNDO_KEEP_FOR_ALL;
     }
-    async publishGroupDirectMessage(groupJid, message, plaintext, type, options, retryContext = {}) {
+    async publishGroupDirectMessage(groupJid, message, plaintext, type, options, retryContext = {}, edit, mediatype, metaNode) {
         const sendOptions = await this.withResolvedMessageId(options);
         const meJid = this.requireCurrentMeJid('sendMessage');
         const participantUserJids = retryContext.forceRefreshParticipants
@@ -172,37 +199,68 @@ class WaMessageDispatchCoordinator {
         if (fanoutDeviceJids.length === 0) {
             throw new Error('group direct send resolved no target devices');
         }
-        await this.sessionResolver.ensureSessionsBatch(fanoutDeviceJids);
-        const participantAddresses = fanoutDeviceJids.map((targetJid) => (0, jid_1.parseSignalAddressFromJid)(targetJid));
-        const encryptedParticipants = await this.signalProtocol.encryptMessagesBatch(participantAddresses.map((address) => ({
-            address,
-            plaintext
-        })));
-        const participants = fanoutDeviceJids.map((targetJid, index) => ({
-            jid: targetJid,
-            encType: encryptedParticipants[index].type,
-            ciphertext: encryptedParticipants[index].ciphertext
-        }));
-        const shouldAttachDeviceIdentity = participants.some((participant) => participant.encType === 'pkmsg');
-        const localPhash = await (0, phash_1.computePhashV2)([...fanoutDeviceJids, senderForPhash]);
-        const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
-            message,
-            stanzaId: sendOptions.id,
-            senderUserJid: (0, jid_1.toUserJid)(senderForPhash),
-            remoteJid: groupJid,
-            context: 'group_direct'
-        });
-        const messageNode = (0, message_1.buildGroupDirectMessageNode)({
+        const resolvedFanoutTargets = await this.sessionResolver.ensureSessionsBatch(fanoutDeviceJids);
+        const uniqueNormalizedFanoutJids = new Set();
+        for (let index = 0; index < fanoutDeviceJids.length; index += 1) {
+            uniqueNormalizedFanoutJids.add((0, jid_1.normalizeDeviceJid)(fanoutDeviceJids[index]));
+        }
+        if (resolvedFanoutTargets.length !== uniqueNormalizedFanoutJids.size) {
+            throw new Error('group direct send resolved incomplete signal sessions');
+        }
+        const participantEncryptRequests = new Array(resolvedFanoutTargets.length);
+        for (let index = 0; index < resolvedFanoutTargets.length; index += 1) {
+            const target = resolvedFanoutTargets[index];
+            participantEncryptRequests[index] = {
+                address: target.address,
+                plaintext
+            };
+        }
+        const encryptedParticipants = await this.signalProtocol.encryptMessagesBatch(participantEncryptRequests, resolvedFanoutTargets);
+        const participants = new Array(resolvedFanoutTargets.length);
+        for (let index = 0; index < resolvedFanoutTargets.length; index += 1) {
+            const target = resolvedFanoutTargets[index];
+            participants[index] = {
+                jid: target.jid,
+                encType: encryptedParticipants[index].type,
+                ciphertext: encryptedParticipants[index].ciphertext
+            };
+        }
+        let shouldAttachDeviceIdentity = false;
+        for (let index = 0; index < participants.length; index += 1) {
+            if (participants[index].encType === 'pkmsg') {
+                shouldAttachDeviceIdentity = true;
+                break;
+            }
+        }
+        const phashTargets = new Array(resolvedFanoutTargets.length + 1);
+        for (let index = 0; index < resolvedFanoutTargets.length; index += 1) {
+            phashTargets[index] = resolvedFanoutTargets[index].jid;
+        }
+        phashTargets[resolvedFanoutTargets.length] = senderForPhash;
+        const [localPhash, reportingArtifacts] = await Promise.all([
+            (0, phash_1.computePhashV2)(phashTargets),
+            this.tryBuildReportingTokenArtifacts({
+                message,
+                stanzaId: sendOptions.id,
+                senderUserJid: (0, jid_1.toUserJid)(senderForPhash),
+                remoteJid: groupJid,
+                context: 'group_direct'
+            })
+        ]);
+        const messageNode = (0, message_1.buildDirectMessageFanoutNode)({
             to: groupJid,
             type,
             id: sendOptions.id,
+            edit,
             phash: localPhash,
             addressingMode,
             participants,
             deviceIdentity: shouldAttachDeviceIdentity
                 ? this.getEncodedSignedDeviceIdentity()
                 : undefined,
-            reportingNode: reportingArtifacts?.node ?? undefined
+            reportingNode: reportingArtifacts?.node ?? undefined,
+            metaNode,
+            mediatype
         });
         const replayPayload = {
             mode: 'plaintext',
@@ -214,7 +272,8 @@ class WaMessageDispatchCoordinator {
             messageIdHint: sendOptions.id ?? messageNode.attrs.id,
             toJid: groupJid,
             type,
-            replayPayload
+            replayPayload,
+            eligibleRequesterDeviceJids: undefined
         }, async () => this.messageClient.publishNode(messageNode, sendOptions));
         const ackError = result.ack.error;
         const serverPhash = result.ack.phash;
@@ -240,11 +299,11 @@ class WaMessageDispatchCoordinator {
                 retried: true,
                 forceRefreshParticipants: true,
                 forceAddressingMode: serverAddressingMode
-            });
+            }, edit, mediatype, metaNode);
         }
         return result;
     }
-    async publishGroupSenderKeyMessage(groupJid, message, plaintext, type, options, retryContext = {}) {
+    async publishGroupSenderKeyMessage(groupJid, message, plaintext, type, options, retryContext = {}, edit, mediatype, metaNode) {
         const sendOptions = await this.withResolvedMessageId(options);
         const meJid = this.requireCurrentMeJid('sendMessage');
         const participantUserJids = retryContext.forceRefreshParticipants
@@ -254,23 +313,36 @@ class WaMessageDispatchCoordinator {
             this.resolveGroupAddressingMode(participantUserJids, groupJid);
         const senderJid = this.resolveSenderForAddressingMode(addressingMode, meJid);
         const sender = (0, jid_1.parseSignalAddressFromJid)(senderJid);
-        const senderKeyDistributionMessage = await this.senderKeyManager.createSenderKeyDistributionMessage(groupJid, sender);
-        const groupCiphertext = await this.senderKeyManager.encryptGroupMessage(groupJid, sender, plaintext);
-        const distributionData = await this.encryptGroupDistributionParticipants(groupJid, sender, senderKeyDistributionMessage, participantUserJids);
+        const { distributionMessage: senderKeyDistributionMessage, ciphertext: groupCiphertext, keyId: senderKeyId } = await this.senderKeyManager.prepareGroupEncryption(groupJid, sender, plaintext);
+        const distributionData = await this.distributionDedup.run(`dist:${groupJid}:${senderKeyId}`, () => this.encryptGroupDistributionParticipants(groupJid, senderKeyId, senderKeyDistributionMessage, participantUserJids));
         const { fanoutDeviceJids, distributionParticipants } = distributionData;
-        const shouldAttachDeviceIdentity = distributionParticipants.some((participant) => participant.encType === 'pkmsg');
-        const localPhash = await (0, phash_1.computePhashV2)([...fanoutDeviceJids, senderJid]);
-        const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
-            message,
-            stanzaId: sendOptions.id,
-            senderUserJid: (0, jid_1.toUserJid)(senderJid),
-            remoteJid: groupJid,
-            context: 'group_sender_key'
-        });
+        let shouldAttachDeviceIdentity = false;
+        for (let index = 0; index < distributionParticipants.length; index += 1) {
+            if (distributionParticipants[index].encType === 'pkmsg') {
+                shouldAttachDeviceIdentity = true;
+                break;
+            }
+        }
+        const phashTargets = new Array(fanoutDeviceJids.length + 1);
+        for (let index = 0; index < fanoutDeviceJids.length; index += 1) {
+            phashTargets[index] = fanoutDeviceJids[index];
+        }
+        phashTargets[fanoutDeviceJids.length] = senderJid;
+        const [localPhash, reportingArtifacts] = await Promise.all([
+            (0, phash_1.computePhashV2)(phashTargets),
+            this.tryBuildReportingTokenArtifacts({
+                message,
+                stanzaId: sendOptions.id,
+                senderUserJid: (0, jid_1.toUserJid)(senderJid),
+                remoteJid: groupJid,
+                context: 'group_sender_key'
+            })
+        ]);
         const messageNode = (0, message_1.buildGroupSenderKeyMessageNode)({
             to: groupJid,
             type,
             id: sendOptions.id,
+            edit,
             phash: localPhash,
             addressingMode,
             groupCiphertext: groupCiphertext.ciphertext,
@@ -278,7 +350,9 @@ class WaMessageDispatchCoordinator {
             deviceIdentity: shouldAttachDeviceIdentity
                 ? this.getEncodedSignedDeviceIdentity()
                 : undefined,
-            reportingNode: reportingArtifacts?.node ?? undefined
+            reportingNode: reportingArtifacts?.node ?? undefined,
+            metaNode,
+            mediatype
         });
         const replayPayload = {
             mode: 'plaintext',
@@ -290,11 +364,15 @@ class WaMessageDispatchCoordinator {
             messageIdHint: sendOptions.id ?? messageNode.attrs.id,
             toJid: groupJid,
             type,
-            replayPayload
+            replayPayload,
+            eligibleRequesterDeviceJids: undefined
         }, async () => this.messageClient.publishNode(messageNode, sendOptions));
-        const distributedAddresses = distributionParticipants.map((participant) => participant.address);
+        const distributedAddresses = new Array(distributionParticipants.length);
+        for (let index = 0; index < distributionParticipants.length; index += 1) {
+            distributedAddresses[index] = distributionParticipants[index].address;
+        }
         try {
-            await this.senderKeyManager.markSenderKeyDistributed(groupJid, sender, distributedAddresses);
+            await this.senderKeyManager.markSenderKeyDistributed(groupJid, senderKeyId, distributedAddresses);
         }
         catch (error) {
             this.logger.warn('failed to mark sender key distribution targets', {
@@ -327,12 +405,13 @@ class WaMessageDispatchCoordinator {
                 retried: true,
                 forceRefreshParticipants: true,
                 forceAddressingMode: serverAddressingMode
-            });
+            }, edit, mediatype, metaNode);
         }
         return result;
     }
     resolveGroupAddressingMode(participantUserJids, groupJid) {
-        for (const participantJid of participantUserJids) {
+        for (let index = 0; index < participantUserJids.length; index += 1) {
+            const participantJid = participantUserJids[index];
             try {
                 if ((0, jid_1.splitJid)(participantJid).server === 'lid') {
                     return 'lid';
@@ -365,7 +444,7 @@ class WaMessageDispatchCoordinator {
         }
         return (0, jid_1.normalizeDeviceJid)(meJid);
     }
-    async encryptGroupDistributionParticipants(groupJid, sender, senderKeyDistributionMessage, participantUserJids) {
+    async encryptGroupDistributionParticipants(groupJid, senderKeyId, senderKeyDistributionMessage, participantUserJids) {
         const distributionPayload = await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode({
             senderKeyDistributionMessage
         }).finish());
@@ -384,7 +463,7 @@ class WaMessageDispatchCoordinator {
             fanoutAddresses[index] = address;
             fanoutTargetsByAddressKey.set((0, jid_2.signalAddressKey)(address), { jid, address });
         }
-        const pendingAddresses = await this.senderKeyManager.filterParticipantsNeedingDistribution(groupJid, sender, fanoutAddresses);
+        const pendingAddresses = await this.senderKeyManager.filterParticipantsNeedingDistribution(groupJid, senderKeyId, fanoutAddresses);
         if (pendingAddresses.length === 0) {
             return {
                 fanoutDeviceJids,
@@ -414,50 +493,82 @@ class WaMessageDispatchCoordinator {
         for (let index = 0; index < pendingTargets.length; index += 1) {
             pendingTargetJids[index] = pendingTargets[index].jid;
         }
+        let availableTargets = [];
+        let prefetchedAvailableTargets;
         try {
-            await this.sessionResolver.ensureSessionsBatch(pendingTargetJids);
+            const resolvedTargets = await this.sessionResolver.ensureSessionsBatch(pendingTargetJids);
+            availableTargets = resolvedTargets;
+            prefetchedAvailableTargets = resolvedTargets;
         }
         catch (error) {
+            const normalized = (0, primitives_1.toError)(error);
+            if (normalized.message === 'identity mismatch') {
+                throw normalized;
+            }
             this.logger.warn('group sender-key distribution session sync failed, continuing with available sessions', {
                 groupJid,
                 requested: pendingTargetJids.length,
-                message: (0, primitives_1.toError)(error).message
+                message: normalized.message
             });
+            const pendingTargetAddresses = new Array(pendingTargets.length);
+            for (let index = 0; index < pendingTargets.length; index += 1) {
+                pendingTargetAddresses[index] = pendingTargets[index].address;
+            }
+            const hasPendingSessions = await this.signalStore.hasSessions(pendingTargetAddresses);
+            const nextAvailableTargets = [];
+            for (let index = 0; index < pendingTargets.length; index += 1) {
+                if (hasPendingSessions[index]) {
+                    nextAvailableTargets.push(pendingTargets[index]);
+                }
+            }
+            availableTargets = nextAvailableTargets;
         }
-        const hasPendingSessions = await this.signalProtocol.hasSessions(pendingTargets.map((target) => target.address));
-        const availableTargets = pendingTargets.filter((_target, index) => hasPendingSessions[index]);
         if (availableTargets.length === 0) {
             return {
                 fanoutDeviceJids,
                 distributionParticipants: []
             };
         }
-        const encryptedDistributionParticipants = await this.signalProtocol.encryptMessagesBatch(availableTargets.map((target) => ({
-            address: target.address,
-            plaintext: distributionPayload
-        })));
-        const distributionParticipants = availableTargets.map((target, index) => ({
-            jid: target.jid,
-            address: target.address,
-            encType: encryptedDistributionParticipants[index].type,
-            ciphertext: encryptedDistributionParticipants[index].ciphertext
-        }));
+        const distributionEncryptRequests = new Array(availableTargets.length);
+        for (let index = 0; index < availableTargets.length; index += 1) {
+            const target = availableTargets[index];
+            distributionEncryptRequests[index] = {
+                address: target.address,
+                plaintext: distributionPayload
+            };
+        }
+        const encryptedDistributionParticipants = await this.signalProtocol.encryptMessagesBatch(distributionEncryptRequests, prefetchedAvailableTargets);
+        const distributionParticipants = new Array(availableTargets.length);
+        for (let index = 0; index < availableTargets.length; index += 1) {
+            const target = availableTargets[index];
+            distributionParticipants[index] = {
+                jid: target.jid,
+                address: target.address,
+                encType: encryptedDistributionParticipants[index].type,
+                ciphertext: encryptedDistributionParticipants[index].ciphertext
+            };
+        }
         return {
             fanoutDeviceJids,
             distributionParticipants
         };
     }
-    async publishDirectSignalMessageWithFanout(recipientJid, message, plaintext, type, options) {
+    async publishDirectSignalMessageWithFanout(recipientJid, message, plaintext, type, options, edit, mediatype, metaNode) {
         const sendOptions = await this.withResolvedMessageId(options);
         const meJid = this.requireCurrentMeJid('sendMessage');
         const meLid = this.getCurrentMeLid();
         const selfDeviceJidForRecipient = this.fanoutResolver.resolveSelfDeviceJidForRecipient(recipientJid, meJid, meLid);
         const deviceJids = await this.fanoutResolver.resolveDirectFanoutDeviceJids(recipientJid, selfDeviceJidForRecipient);
-        const targets = deviceJids.map((jid) => ({
-            jid,
-            normalizedJid: (0, jid_1.normalizeDeviceJid)(jid),
-            userJid: (0, jid_1.toUserJid)(jid)
-        }));
+        const targets = new Array(deviceJids.length);
+        for (let index = 0; index < deviceJids.length; index += 1) {
+            const jid = deviceJids[index];
+            const parsed = (0, jid_1.parseJidFull)(jid);
+            targets[index] = {
+                jid,
+                normalizedJid: parsed.normalizedJid,
+                userJid: parsed.userJid
+            };
+        }
         const recipientUserJid = (0, jid_1.toUserJid)(recipientJid);
         const meUserJid = (0, jid_1.toUserJid)(selfDeviceJidForRecipient);
         this.logger.debug('wa client publish signal fanout', {
@@ -474,30 +585,75 @@ class WaMessageDispatchCoordinator {
                 }
             }
         }
-        await this.sessionResolver.ensureSessionsBatch(deviceJids, expectedIdentityByJid);
-        const hasSelfDeviceFanout = targets.some((target) => target.userJid === meUserJid);
+        const resolvedFanoutTargets = await this.sessionResolver.ensureSessionsBatch(deviceJids, expectedIdentityByJid);
+        const resolvedFanoutTargetsByJid = new Map();
+        for (let index = 0; index < resolvedFanoutTargets.length; index += 1) {
+            const target = resolvedFanoutTargets[index];
+            resolvedFanoutTargetsByJid.set((0, jid_1.normalizeDeviceJid)(target.jid), target);
+        }
+        for (let index = 0; index < targets.length; index += 1) {
+            if (!resolvedFanoutTargetsByJid.has(targets[index].normalizedJid)) {
+                throw new Error('direct fanout missing signal sessions for one or more targets');
+            }
+        }
+        let hasSelfDeviceFanout = false;
+        for (let index = 0; index < targets.length; index += 1) {
+            if (targets[index].userJid === meUserJid) {
+                hasSelfDeviceFanout = true;
+                break;
+            }
+        }
         const selfDevicePlaintext = hasSelfDeviceFanout
             ? await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode((0, device_sent_1.wrapDeviceSentMessage)(message, recipientUserJid)).finish())
             : null;
-        const participantRequests = targets.map((target) => ({
-            target,
-            address: (0, jid_1.parseSignalAddressFromJid)(target.jid),
-            expectedIdentity: target.userJid === recipientUserJid ? sendOptions.expectedIdentity : undefined,
-            plaintext: selfDevicePlaintext && target.userJid === meUserJid
-                ? selfDevicePlaintext
-                : plaintext
-        }));
-        const encryptedParticipants = await this.signalProtocol.encryptMessagesBatch(participantRequests.map((request) => ({
-            address: request.address,
-            plaintext: request.plaintext,
-            expectedIdentity: request.expectedIdentity
-        })));
-        const participants = participantRequests.map((request, index) => ({
-            jid: request.target.jid,
-            encType: encryptedParticipants[index].type,
-            ciphertext: encryptedParticipants[index].ciphertext
-        }));
-        const shouldAttachDeviceIdentity = participants.some((participant) => participant.encType === 'pkmsg');
+        const participantRequests = new Array(targets.length);
+        for (let index = 0; index < targets.length; index += 1) {
+            const target = targets[index];
+            const resolvedTarget = resolvedFanoutTargetsByJid.get(target.normalizedJid);
+            if (!resolvedTarget) {
+                throw new Error('direct fanout missing signal session for target');
+            }
+            participantRequests[index] = {
+                target,
+                address: resolvedTarget.address,
+                session: resolvedTarget.session,
+                expectedIdentity: target.userJid === recipientUserJid ? sendOptions.expectedIdentity : undefined,
+                plaintext: selfDevicePlaintext && target.userJid === meUserJid
+                    ? selfDevicePlaintext
+                    : plaintext
+            };
+        }
+        const encryptRequests = new Array(participantRequests.length);
+        const prefetchedSessions = new Array(participantRequests.length);
+        for (let index = 0; index < participantRequests.length; index += 1) {
+            const request = participantRequests[index];
+            encryptRequests[index] = {
+                address: request.address,
+                plaintext: request.plaintext,
+                expectedIdentity: request.expectedIdentity
+            };
+            prefetchedSessions[index] = {
+                address: request.address,
+                session: request.session
+            };
+        }
+        const encryptedParticipants = await this.signalProtocol.encryptMessagesBatch(encryptRequests, prefetchedSessions);
+        const participants = new Array(participantRequests.length);
+        for (let index = 0; index < participantRequests.length; index += 1) {
+            const request = participantRequests[index];
+            participants[index] = {
+                jid: request.target.jid,
+                encType: encryptedParticipants[index].type,
+                ciphertext: encryptedParticipants[index].ciphertext
+            };
+        }
+        let shouldAttachDeviceIdentity = false;
+        for (let index = 0; index < participants.length; index += 1) {
+            if (participants[index].encType === 'pkmsg') {
+                shouldAttachDeviceIdentity = true;
+                break;
+            }
+        }
         const deviceIdentity = shouldAttachDeviceIdentity
             ? this.getEncodedSignedDeviceIdentity()
             : undefined;
@@ -508,13 +664,28 @@ class WaMessageDispatchCoordinator {
             remoteJid: recipientUserJid,
             context: 'direct_fanout'
         });
+        let privacyTokenNode;
+        try {
+            privacyTokenNode =
+                (await this.privacyTokenDedup.run(`pt:${recipientUserJid}`, () => this.resolvePrivacyTokenNode(recipientUserJid))) ?? undefined;
+        }
+        catch (error) {
+            this.logger.warn('privacy token resolution failed', {
+                to: recipientUserJid,
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
         const messageNode = (0, message_1.buildDirectMessageFanoutNode)({
             to: recipientJid,
             type,
             id: sendOptions.id,
+            edit,
             participants,
             deviceIdentity,
-            reportingNode: reportingArtifacts?.node ?? undefined
+            reportingNode: reportingArtifacts?.node ?? undefined,
+            privacyTokenNode,
+            metaNode,
+            mediatype
         });
         const replayPayload = {
             mode: 'plaintext',
@@ -522,12 +693,15 @@ class WaMessageDispatchCoordinator {
             type,
             plaintext
         };
-        return this.retryTracker.track({
+        const result = await this.retryTracker.track({
             messageIdHint: sendOptions.id ?? messageNode.attrs.id,
             toJid: recipientJid,
             type,
-            replayPayload
+            replayPayload,
+            eligibleRequesterDeviceJids: deviceJids
         }, async () => this.messageClient.publishNode(messageNode, sendOptions));
+        this.onDirectMessageSent(recipientUserJid);
+        return result;
     }
     async withResolvedMessageId(options) {
         const normalizedId = options.id?.trim();
@@ -595,6 +769,25 @@ class WaMessageDispatchCoordinator {
         }
         return _proto_1.proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
     }
+    resolveUserIcdc(userJid, localIdentity) {
+        return this.icdcDedup.run(`icdc:${userJid}:${localIdentity ? '1' : '0'}`, async () => {
+            try {
+                const snapshots = await this.deviceListStore.getUserDevicesBatch([userJid]);
+                const snapshot = snapshots[0];
+                if (!snapshot || snapshot.deviceJids.length === 0) {
+                    return null;
+                }
+                return (0, icdc_1.resolveIcdcMeta)(snapshot.deviceJids, this.signalStore, snapshot.updatedAtMs, localIdentity);
+            }
+            catch (error) {
+                this.logger.trace('icdc resolution failed', {
+                    userJid,
+                    message: (0, primitives_1.toError)(error).message
+                });
+                return null;
+            }
+        });
+    }
     requireCurrentMeJid(context) {
         const meJid = this.getCurrentMeJid();
         if (meJid) {