zapo-js 0.1.2 → 0.3.0

package/dist/esm/client/coordinators/WaMessageDispatchCoordinator.js

@@ -1,20 +1,25 @@
 import { randomBytesAsync, sha256 } from '../../crypto/index.js';
+import { md5Bytes } from '../../crypto/core/primitives.js';
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { ensureMessageSecret } from '../../message/index.js';
-import { resolveMessageTypeAttr } from '../../message/content.js';
+import { needsSecretPersistence, resolveEditAttr, resolveEncMediaType, resolveMessageTypeAttr, resolveMetaAttrs } from '../../message/content.js';
 import { wrapDeviceSentMessage } from '../../message/device-sent.js';
+import { injectDeviceListMetadata, resolveIcdcMeta } from '../../message/icdc.js';
 import { writeRandomPadMax16 } from '../../message/padding.js';
 import { computePhashV2 } from '../../message/phash.js';
 import { buildReportingTokenArtifacts } from '../../message/reporting-token.js';
 import { proto } from '../../proto.js';
 import { WA_DEFAULTS } from '../../protocol/constants.js';
-import { isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parseSignalAddressFromJid, splitJid, toUserJid } from '../../protocol/jid.js';
-import { signalAddressKey } from '../../protocol/jid.js';
+import { isGroupJid, isLidJid, normalizeDeviceJid, normalizeRecipientJid, parseJidFull, parseSignalAddressFromJid, signalAddressKey, toUserJid } from '../../protocol/jid.js';
 import { encodeBinaryNode } from '../../transport/binary/index.js';
-import { buildDirectMessageFanoutNode, buildGroupDirectMessageNode, buildGroupSenderKeyMessageNode } from '../../transport/node/builders/message.js';
+import { buildDirectMessageFanoutNode, buildGroupSenderKeyMessageNode, buildMetaNode } from '../../transport/node/builders/message.js';
 import { bytesToHex, concatBytes, TEXT_ENCODER } from '../../util/bytes.js';
 import { toError } from '../../util/primitives.js';
 export class WaMessageDispatchCoordinator {
     constructor(options) {
+        this.icdcDedup = new PromiseDedup();
+        this.privacyTokenDedup = new PromiseDedup();
+        this.distributionDedup = new PromiseDedup();
         this.logger = options.logger;
         this.messageClient = options.messageClient;
         this.retryTracker = options.retryTracker;
@@ -25,9 +30,18 @@ export 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', {
@@ -68,7 +82,8 @@ export 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 = {}) {
@@ -98,7 +113,8 @@ export 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,
@@ -118,16 +134,47 @@ export class WaMessageDispatchCoordinator {
             this.withResolvedMessageId(options)
         ]);
         const messageWithSecret = await ensureMessageSecret(message);
-        const plaintext = await writeRandomPadMax16(proto.Message.encode(messageWithSecret).finish());
-        const type = resolveMessageTypeAttr(messageWithSecret);
-        if (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 &&
+            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: toError(error).message
+                });
+            });
+        }
+        const meJid = this.getCurrentMeJid();
+        const regInfo = meJid ? await this.signalStore.getRegistrationInfo() : null;
+        const localPubKey = regInfo?.identityKeyPair.pubKey;
+        const meParsed = meJid ? parseJidFull(meJid) : undefined;
+        const meUserJid = meParsed?.userJid;
+        const localIdentity = meParsed && localPubKey ? { address: meParsed.address, pubKey: localPubKey } : undefined;
+        const isGroup = isGroupJid(recipientJid);
+        const [senderIcdc, recipientIcdc] = await Promise.all([
+            meUserJid ? this.resolveUserIcdc(meUserJid, localIdentity) : null,
+            !isGroup ? this.resolveUserIcdc(toUserJid(recipientJid)) : null
+        ]);
+        const messageWithIcdc = injectDeviceListMetadata(messageWithSecret, senderIcdc, recipientIcdc);
+        const plaintext = await writeRandomPadMax16(proto.Message.encode(messageWithIcdc).finish());
+        const type = resolveMessageTypeAttr(messageWithIcdc);
+        const edit = resolveEditAttr(messageWithIcdc, sendOptions.subtype) ?? undefined;
+        const mediatype = resolveEncMediaType(messageWithIcdc) ?? undefined;
+        const metaAttrs = resolveMetaAttrs(messageWithIcdc);
+        const metaNode = metaAttrs ? 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 = 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 = parseSignalAddressFromJid(jid);
@@ -156,7 +203,7 @@ export class WaMessageDispatchCoordinator {
         }
         return message.keepInChatMessage?.keepType === 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
@@ -169,37 +216,68 @@ export 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) => 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 computePhashV2([...fanoutDeviceJids, senderForPhash]);
-        const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
-            message,
-            stanzaId: sendOptions.id,
-            senderUserJid: toUserJid(senderForPhash),
-            remoteJid: groupJid,
-            context: 'group_direct'
-        });
-        const messageNode = buildGroupDirectMessageNode({
+        const resolvedFanoutTargets = await this.sessionResolver.ensureSessionsBatch(fanoutDeviceJids);
+        const uniqueNormalizedFanoutJids = new Set();
+        for (let index = 0; index < fanoutDeviceJids.length; index += 1) {
+            uniqueNormalizedFanoutJids.add(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([
+            computePhashV2(phashTargets),
+            this.tryBuildReportingTokenArtifacts({
+                message,
+                stanzaId: sendOptions.id,
+                senderUserJid: toUserJid(senderForPhash),
+                remoteJid: groupJid,
+                context: 'group_direct'
+            })
+        ]);
+        const messageNode = 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',
@@ -211,7 +289,8 @@ export 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;
@@ -237,11 +316,11 @@ export 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
@@ -251,23 +330,36 @@ export class WaMessageDispatchCoordinator {
             this.resolveGroupAddressingMode(participantUserJids, groupJid);
         const senderJid = this.resolveSenderForAddressingMode(addressingMode, meJid);
         const sender = 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 computePhashV2([...fanoutDeviceJids, senderJid]);
-        const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
-            message,
-            stanzaId: sendOptions.id,
-            senderUserJid: 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([
+            computePhashV2(phashTargets),
+            this.tryBuildReportingTokenArtifacts({
+                message,
+                stanzaId: sendOptions.id,
+                senderUserJid: toUserJid(senderJid),
+                remoteJid: groupJid,
+                context: 'group_sender_key'
+            })
+        ]);
         const messageNode = buildGroupSenderKeyMessageNode({
             to: groupJid,
             type,
             id: sendOptions.id,
+            edit,
             phash: localPhash,
             addressingMode,
             groupCiphertext: groupCiphertext.ciphertext,
@@ -275,7 +367,9 @@ export class WaMessageDispatchCoordinator {
             deviceIdentity: shouldAttachDeviceIdentity
                 ? this.getEncodedSignedDeviceIdentity()
                 : undefined,
-            reportingNode: reportingArtifacts?.node ?? undefined
+            reportingNode: reportingArtifacts?.node ?? undefined,
+            metaNode,
+            mediatype
         });
         const replayPayload = {
             mode: 'plaintext',
@@ -287,11 +381,15 @@ export 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', {
@@ -324,19 +422,14 @@ export class WaMessageDispatchCoordinator {
                 retried: true,
                 forceRefreshParticipants: true,
                 forceAddressingMode: serverAddressingMode
-            });
+            }, edit, mediatype, metaNode);
         }
         return result;
     }
     resolveGroupAddressingMode(participantUserJids, groupJid) {
-        for (const participantJid of participantUserJids) {
-            try {
-                if (splitJid(participantJid).server === 'lid') {
-                    return 'lid';
-                }
-            }
-            catch (error) {
-                this.logger.trace('ignoring malformed participant jid in addressing mode resolution', { participantJid, message: toError(error).message });
+        for (let index = 0; index < participantUserJids.length; index += 1) {
+            if (isLidJid(participantUserJids[index])) {
+                return 'lid';
             }
         }
         this.logger.trace('group addressing mode resolved to pn (default)', {
@@ -362,7 +455,7 @@ export class WaMessageDispatchCoordinator {
         }
         return normalizeDeviceJid(meJid);
     }
-    async encryptGroupDistributionParticipants(groupJid, sender, senderKeyDistributionMessage, participantUserJids) {
+    async encryptGroupDistributionParticipants(groupJid, senderKeyId, senderKeyDistributionMessage, participantUserJids) {
         const distributionPayload = await writeRandomPadMax16(proto.Message.encode({
             senderKeyDistributionMessage
         }).finish());
@@ -381,7 +474,7 @@ export class WaMessageDispatchCoordinator {
             fanoutAddresses[index] = address;
             fanoutTargetsByAddressKey.set(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,
@@ -411,50 +504,82 @@ export 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 = 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: 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: normalizeDeviceJid(jid),
-            userJid: toUserJid(jid)
-        }));
+        const targets = new Array(deviceJids.length);
+        for (let index = 0; index < deviceJids.length; index += 1) {
+            const jid = deviceJids[index];
+            const parsed = parseJidFull(jid);
+            targets[index] = {
+                jid,
+                normalizedJid: parsed.normalizedJid,
+                userJid: parsed.userJid
+            };
+        }
         const recipientUserJid = toUserJid(recipientJid);
         const meUserJid = toUserJid(selfDeviceJidForRecipient);
         this.logger.debug('wa client publish signal fanout', {
@@ -471,30 +596,75 @@ export 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(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 writeRandomPadMax16(proto.Message.encode(wrapDeviceSentMessage(message, recipientUserJid)).finish())
             : null;
-        const participantRequests = targets.map((target) => ({
-            target,
-            address: 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;
@@ -505,13 +675,28 @@ export 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: toError(error).message
+            });
+        }
         const messageNode = 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',
@@ -519,12 +704,15 @@ export 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();
@@ -545,9 +733,20 @@ export class WaMessageDispatchCoordinator {
     async generateOutgoingMessageId() {
         try {
             const meUserJid = 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 = concatBytes([
+                    timestampBytes,
+                    TEXT_ENCODER.encode(meUserJid),
+                    await randomBytesAsync(16)
+                ]);
+                const digest = md5Bytes(entropy);
+                digest[0] = 0xac;
+                return bytesToHex(digest).toUpperCase();
+            }
+            dv.setBigUint64(0, BigInt(Math.floor(Date.now() / 1000)), false);
             const entropy = concatBytes([
                 timestampBytes,
                 TEXT_ENCODER.encode(meUserJid),
@@ -557,9 +756,14 @@ export class WaMessageDispatchCoordinator {
             return `3EB0${bytesToHex(digest.subarray(0, 9)).toUpperCase()}`;
         }
         catch (error) {
-            this.logger.warn('failed to generate sha256 message id, falling back to random id', {
+            this.logger.warn('failed to generate message id, falling back to random', {
                 message: toError(error).message
             });
+            if (this.mobileMessageIdFormat) {
+                const bytes = await randomBytesAsync(16);
+                bytes[0] = 0xac;
+                return bytesToHex(bytes).toUpperCase();
+            }
             return `3EB0${bytesToHex(await randomBytesAsync(8)).toUpperCase()}`;
         }
     }
@@ -588,10 +792,29 @@ export class WaMessageDispatchCoordinator {
     getEncodedSignedDeviceIdentity() {
         const signedIdentity = this.getCurrentSignedIdentity();
         if (!signedIdentity) {
-            throw new Error('missing signed identity for pkmsg fanout');
+            return undefined;
         }
         return 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 resolveIcdcMeta(snapshot.deviceJids, this.identityStore, snapshot.updatedAtMs, localIdentity, this.getIcdcHashLength?.());
+            }
+            catch (error) {
+                this.logger.trace('icdc resolution failed', {
+                    userJid,
+                    message: toError(error).message
+                });
+                return null;
+            }
+        });
+    }
     requireCurrentMeJid(context) {
         const meJid = this.getCurrentMeJid();
         if (meJid) {