zapo-js 0.1.2 → 0.3.0

package/dist/client/coordinators/WaMessageDispatchCoordinator.js

@@ -2,22 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageDispatchCoordinator = void 0;
 const _crypto_1 = require("../../crypto/index.js");
+const primitives_1 = require("../../crypto/core/primitives");
+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");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
-const jid_2 = require("../../protocol/jid");
 const binary_1 = require("../../transport/binary");
 const message_1 = require("../../transport/node/builders/message");
 const bytes_1 = require("../../util/bytes");
-const primitives_1 = require("../../util/primitives");
+const primitives_2 = 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,18 @@ class WaMessageDispatchCoordinator {
         this.buildMessageContent = options.buildMessageContent;
         this.senderKeyManager = options.senderKeyManager;
         this.signalProtocol = options.signalProtocol;
+        this.signalStore = options.signalStore;
+        this.sessionStore = options.sessionStore;
+        this.identityStore = options.identityStore;
+        this.deviceListStore = options.deviceListStore;
+        this.messageSecretStore = options.messageSecretStore;
         this.getCurrentMeJid = options.getCurrentMeJid;
         this.getCurrentMeLid = options.getCurrentMeLid;
         this.getCurrentSignedIdentity = options.getCurrentSignedIdentity;
+        this.resolvePrivacyTokenNode = options.resolvePrivacyTokenNode;
+        this.onDirectMessageSent = options.onDirectMessageSent;
+        this.getIcdcHashLength = options.getIcdcHashLength;
+        this.mobileMessageIdFormat = options.mobileMessageIdFormat ?? false;
     }
     async publishMessageNode(node, options = {}) {
         this.logger.debug('wa client publish message node', {
@@ -71,7 +85,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 +116,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 +137,47 @@ 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 rawSecret = messageWithSecret.messageContextInfo?.messageSecret;
+        if (rawSecret &&
+            rawSecret.length > 0 &&
+            sendOptions.id &&
+            (0, content_1.needsSecretPersistence)(messageWithSecret)) {
+            const meJid = this.getCurrentMeJid() ?? '';
+            void this.messageSecretStore
+                .set(sendOptions.id, { secret: rawSecret, senderJid: meJid })
+                .catch((error) => {
+                this.logger.warn('failed to persist outgoing message secret', {
+                    id: sendOptions.id,
+                    message: (0, primitives_2.toError)(error).message
+                });
+            });
+        }
+        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 +206,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 +219,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 +292,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 +319,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 +333,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 +370,9 @@ class WaMessageDispatchCoordinator {
             deviceIdentity: shouldAttachDeviceIdentity
                 ? this.getEncodedSignedDeviceIdentity()
                 : undefined,
-            reportingNode: reportingArtifacts?.node ?? undefined
+            reportingNode: reportingArtifacts?.node ?? undefined,
+            metaNode,
+            mediatype
         });
         const replayPayload = {
             mode: 'plaintext',
@@ -290,17 +384,21 @@ 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', {
                 groupJid,
                 participants: distributedAddresses.length,
-                message: (0, primitives_1.toError)(error).message
+                message: (0, primitives_2.toError)(error).message
             });
         }
         const ackError = result.ack.error;
@@ -327,19 +425,14 @@ class WaMessageDispatchCoordinator {
                 retried: true,
                 forceRefreshParticipants: true,
                 forceAddressingMode: serverAddressingMode
-            });
+            }, edit, mediatype, metaNode);
         }
         return result;
     }
     resolveGroupAddressingMode(participantUserJids, groupJid) {
-        for (const participantJid of participantUserJids) {
-            try {
-                if ((0, jid_1.splitJid)(participantJid).server === 'lid') {
-                    return 'lid';
-                }
-            }
-            catch (error) {
-                this.logger.trace('ignoring malformed participant jid in addressing mode resolution', { participantJid, message: (0, primitives_1.toError)(error).message });
+        for (let index = 0; index < participantUserJids.length; index += 1) {
+            if ((0, jid_1.isLidJid)(participantUserJids[index])) {
+                return 'lid';
             }
         }
         this.logger.trace('group addressing mode resolved to pn (default)', {
@@ -358,14 +451,14 @@ class WaMessageDispatchCoordinator {
                 catch (error) {
                     this.logger.trace('ignoring malformed me lid jid', {
                         meLid,
-                        message: (0, primitives_1.toError)(error).message
+                        message: (0, primitives_2.toError)(error).message
                     });
                 }
             }
         }
         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());
@@ -382,9 +475,9 @@ class WaMessageDispatchCoordinator {
             const jid = fanoutDeviceJids[index];
             const address = (0, jid_1.parseSignalAddressFromJid)(jid);
             fanoutAddresses[index] = address;
-            fanoutTargetsByAddressKey.set((0, jid_2.signalAddressKey)(address), { jid, address });
+            fanoutTargetsByAddressKey.set((0, jid_1.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,
@@ -394,7 +487,7 @@ class WaMessageDispatchCoordinator {
         const pendingAddressKeys = new Set();
         const pendingTargets = [];
         for (let index = 0; index < pendingAddresses.length; index += 1) {
-            const key = (0, jid_2.signalAddressKey)(pendingAddresses[index]);
+            const key = (0, jid_1.signalAddressKey)(pendingAddresses[index]);
             if (pendingAddressKeys.has(key)) {
                 continue;
             }
@@ -414,50 +507,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_2.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.sessionStore.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 +599,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 +678,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_2.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 +707,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();
@@ -548,9 +736,20 @@ class WaMessageDispatchCoordinator {
     async generateOutgoingMessageId() {
         try {
             const meUserJid = (0, jid_1.toUserJid)(this.requireCurrentMeJid('sendMessage'));
-            const timestampSeconds = Math.floor(Date.now() / 1000);
             const timestampBytes = new Uint8Array(8);
-            new DataView(timestampBytes.buffer, timestampBytes.byteOffset, timestampBytes.byteLength).setBigUint64(0, BigInt(timestampSeconds), false);
+            const dv = new DataView(timestampBytes.buffer, timestampBytes.byteOffset, timestampBytes.byteLength);
+            if (this.mobileMessageIdFormat) {
+                dv.setBigUint64(0, BigInt(Date.now()), false);
+                const entropy = (0, bytes_1.concatBytes)([
+                    timestampBytes,
+                    bytes_1.TEXT_ENCODER.encode(meUserJid),
+                    await (0, _crypto_1.randomBytesAsync)(16)
+                ]);
+                const digest = (0, primitives_1.md5Bytes)(entropy);
+                digest[0] = 0xac;
+                return (0, bytes_1.bytesToHex)(digest).toUpperCase();
+            }
+            dv.setBigUint64(0, BigInt(Math.floor(Date.now() / 1000)), false);
             const entropy = (0, bytes_1.concatBytes)([
                 timestampBytes,
                 bytes_1.TEXT_ENCODER.encode(meUserJid),
@@ -560,9 +759,14 @@ class WaMessageDispatchCoordinator {
             return `3EB0${(0, bytes_1.bytesToHex)(digest.subarray(0, 9)).toUpperCase()}`;
         }
         catch (error) {
-            this.logger.warn('failed to generate sha256 message id, falling back to random id', {
-                message: (0, primitives_1.toError)(error).message
+            this.logger.warn('failed to generate message id, falling back to random', {
+                message: (0, primitives_2.toError)(error).message
             });
+            if (this.mobileMessageIdFormat) {
+                const bytes = await (0, _crypto_1.randomBytesAsync)(16);
+                bytes[0] = 0xac;
+                return (0, bytes_1.bytesToHex)(bytes).toUpperCase();
+            }
             return `3EB0${(0, bytes_1.bytesToHex)(await (0, _crypto_1.randomBytesAsync)(8)).toUpperCase()}`;
         }
     }
@@ -583,7 +787,7 @@ class WaMessageDispatchCoordinator {
                 context: input.context,
                 id: input.stanzaId,
                 remoteJid: input.remoteJid,
-                message: (0, primitives_1.toError)(error).message
+                message: (0, primitives_2.toError)(error).message
             });
             return null;
         }
@@ -591,10 +795,29 @@ class WaMessageDispatchCoordinator {
     getEncodedSignedDeviceIdentity() {
         const signedIdentity = this.getCurrentSignedIdentity();
         if (!signedIdentity) {
-            throw new Error('missing signed identity for pkmsg fanout');
+            return undefined;
         }
         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.identityStore, snapshot.updatedAtMs, localIdentity, this.getIcdcHashLength?.());
+            }
+            catch (error) {
+                this.logger.trace('icdc resolution failed', {
+                    userJid,
+                    message: (0, primitives_2.toError)(error).message
+                });
+                return null;
+            }
+        });
+    }
     requireCurrentMeJid(context) {
         const meJid = this.getCurrentMeJid();
         if (meJid) {