zapo-js 0.1.0 → 0.1.2

package/dist/client/history-sync.js

@@ -4,7 +4,6 @@ exports.processHistorySyncNotification = processHistorySyncNotification;
 const node_util_1 = require("node:util");
 const node_zlib_1 = require("node:zlib");
 const _proto_1 = require("../proto.js");
-const base64_1 = require("../util/base64");
 const bytes_1 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 const unzipAsync = (0, node_util_1.promisify)(node_zlib_1.unzip);
@@ -31,15 +30,58 @@ async function processHistorySyncNotification(deps, notification) {
         pushnames: historySync.pushnames.length
     });
     const nowMs = Date.now();
+    const contacts = [];
+    for (const pn of historySync.pushnames) {
+        if (!pn.id) {
+            continue;
+        }
+        contacts.push({
+            jid: pn.id,
+            pushName: pn.pushname ?? undefined,
+            lastUpdatedMs: nowMs
+        });
+    }
+    const threads = [];
+    const messages = [];
     let messagesCount = 0;
-    const conversationPromises = [];
     for (const conversation of historySync.conversations) {
-        conversationPromises.push(persistConversation(deps, conversation, nowMs).then((count) => {
-            messagesCount += count;
-        }));
+        const threadJid = conversation.id;
+        if (!threadJid) {
+            deps.logger.debug('skipping history sync conversation without thread jid');
+            continue;
+        }
+        threads.push({
+            jid: threadJid,
+            name: conversation.name ?? undefined,
+            unreadCount: conversation.unreadCount ?? undefined,
+            archived: conversation.archived ?? undefined,
+            pinned: conversation.pinned ?? undefined,
+            muteEndMs: (0, primitives_1.longToNumber)(conversation.muteEndTime) || undefined,
+            markedAsUnread: conversation.markedAsUnread ?? undefined,
+            ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
+        });
+        for (const histMsg of conversation.messages ?? []) {
+            const webMsg = histMsg.message;
+            if (!webMsg?.key?.id) {
+                continue;
+            }
+            const timestampMs = (0, primitives_1.longToNumber)(webMsg.messageTimestamp) * 1000;
+            messages.push({
+                id: webMsg.key.id,
+                threadJid,
+                senderJid: webMsg.key.participant ?? undefined,
+                fromMe: webMsg.key.fromMe === true,
+                timestampMs: timestampMs || undefined,
+                messageBytes: webMsg.message
+                    ? _proto_1.proto.Message.encode(webMsg.message).finish()
+                    : undefined
+            });
+            messagesCount += 1;
+        }
     }
-    const pushnamePromise = persistPushnames(deps, historySync.pushnames, nowMs);
-    await Promise.all([...conversationPromises, pushnamePromise]);
+    await deps.contactStore.upsertBatch(contacts);
+    await deps.threadStore.upsertBatch(threads);
+    await deps.messageStore.upsertBatch(messages);
     const event = {
         syncType,
         messagesCount,
@@ -52,14 +94,14 @@ async function processHistorySyncNotification(deps, notification) {
 }
 async function downloadHistorySyncBlob(deps, notification) {
     if (notification.initialHistBootstrapInlinePayload) {
-        return (0, base64_1.decodeProtoBytes)(notification.initialHistBootstrapInlinePayload, 'initialHistBootstrapInlinePayload');
+        return (0, bytes_1.decodeProtoBytes)(notification.initialHistBootstrapInlinePayload, 'initialHistBootstrapInlinePayload');
     }
     if (!notification.directPath) {
         throw new Error('history sync notification missing directPath');
     }
-    const mediaKey = (0, base64_1.decodeProtoBytes)(notification.mediaKey, 'history sync mediaKey');
-    const fileSha256 = (0, base64_1.decodeProtoBytes)(notification.fileSha256, 'history sync fileSha256');
-    const fileEncSha256 = (0, base64_1.decodeProtoBytes)(notification.fileEncSha256, 'history sync fileEncSha256');
+    const mediaKey = (0, bytes_1.decodeProtoBytes)(notification.mediaKey, 'history sync mediaKey');
+    const fileSha256 = (0, bytes_1.decodeProtoBytes)(notification.fileSha256, 'history sync fileSha256');
+    const fileEncSha256 = (0, bytes_1.decodeProtoBytes)(notification.fileEncSha256, 'history sync fileEncSha256');
     return deps.mediaTransfer.downloadAndDecrypt({
         directPath: notification.directPath,
         mediaType: 'history',
@@ -68,55 +110,3 @@ async function downloadHistorySyncBlob(deps, notification) {
         fileEncSha256
     });
 }
-async function persistConversation(deps, conversation, _nowMs) {
-    const threadJid = conversation.id;
-    if (!threadJid) {
-        deps.logger.debug('skipping history sync conversation without thread jid');
-        return 0;
-    }
-    const messages = conversation.messages ?? [];
-    const messageRecords = [];
-    for (const histMsg of messages) {
-        const webMsg = histMsg.message;
-        if (!webMsg?.key?.id) {
-            continue;
-        }
-        const timestampMs = (0, primitives_1.longToNumber)(webMsg.messageTimestamp) * 1000;
-        const messageBytes = webMsg.message
-            ? _proto_1.proto.Message.encode(webMsg.message).finish()
-            : undefined;
-        messageRecords.push({
-            id: webMsg.key.id,
-            threadJid,
-            senderJid: webMsg.key.participant ?? undefined,
-            fromMe: webMsg.key.fromMe === true,
-            timestampMs: timestampMs || undefined,
-            messageBytes
-        });
-    }
-    const threadPromise = deps.threadStore.upsert({
-        jid: threadJid,
-        name: conversation.name ?? undefined,
-        unreadCount: conversation.unreadCount ?? undefined,
-        archived: conversation.archived ?? undefined,
-        pinned: conversation.pinned ?? undefined,
-        muteEndMs: (0, primitives_1.longToNumber)(conversation.muteEndTime) || undefined,
-        markedAsUnread: conversation.markedAsUnread ?? undefined,
-        ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
-    });
-    const messagePromises = messageRecords.map((record) => deps.messageStore.upsert(record));
-    await Promise.all([threadPromise, ...messagePromises]);
-    return messageRecords.length;
-}
-async function persistPushnames(deps, pushnames, nowMs) {
-    if (pushnames.length === 0) {
-        return;
-    }
-    await Promise.all(pushnames
-        .filter((pn) => !!pn.id)
-        .map((pn) => deps.contactStore.upsert({
-        jid: pn.id,
-        pushName: pn.pushname ?? undefined,
-        lastUpdatedMs: nowMs
-    })));
-}

package/dist/client/incoming.js

@@ -12,7 +12,6 @@ const constants_1 = require("../protocol/constants");
 const message_1 = require("../transport/node/builders/message");
 const pairing_1 = require("../transport/node/builders/pairing");
 const helpers_1 = require("../transport/node/helpers");
-const parse_1 = require("../transport/stream/parse");
 const primitives_1 = require("../util/primitives");
 const LOGOUT_FAILURE_REASONS = new Set([401, 403, 406]);
 const DISCONNECT_FAILURE_REASONS = new Set([405, 409, 503]);
@@ -128,8 +127,8 @@ function createIncomingReceiptHandler(options) {
 }
 function createIncomingFailureHandler(options) {
     return async (node) => {
-        const reason = (0, parse_1.parseOptionalInt)(node.attrs.reason);
-        const code = (0, parse_1.parseOptionalInt)(node.attrs.code);
+        const reason = (0, primitives_1.parseOptionalInt)(node.attrs.reason);
+        const code = (0, primitives_1.parseOptionalInt)(node.attrs.code);
         options.emitIncomingFailure({
             ...createIncomingBaseEvent(node),
             failureReason: reason,
@@ -150,47 +149,50 @@ function createIncomingNotificationHandler(options) {
         const notificationType = node.attrs.type ?? '';
         const classification = classifyNotificationType(notificationType);
         const firstChildTag = (0, helpers_1.getFirstNodeChild)(node)?.tag;
+        const baseEvent = createIncomingBaseEvent(node);
         const serverSyncCollections = notificationType === 'server_sync'
-            ? (0, helpers_1.getNodeChildrenByTag)(node, constants_1.WA_NODE_TAGS.COLLECTION)
-                .map((collectionNode) => collectionNode.attrs.name)
-                .filter((name) => typeof name === 'string' && name.length > 0)
+            ? (0, helpers_1.getNodeChildrenNonEmptyAttrValuesByTag)(node, constants_1.WA_NODE_TAGS.COLLECTION, 'name')
             : [];
+        let details;
+        if (firstChildTag || serverSyncCollections.length > 0) {
+            details = {};
+            if (firstChildTag) {
+                details.firstChildTag = firstChildTag;
+            }
+            if (serverSyncCollections.length > 0) {
+                details.collections = serverSyncCollections;
+            }
+        }
         options.emitIncomingNotification({
-            ...createIncomingBaseEvent(node),
+            ...baseEvent,
             notificationType,
             classification,
-            details: firstChildTag || serverSyncCollections.length > 0
-                ? {
-                    ...(firstChildTag ? { firstChildTag } : {}),
-                    ...(serverSyncCollections.length > 0
-                        ? { collections: serverSyncCollections }
-                        : {})
-                }
-                : undefined
+            details
         });
         if (classification === 'out_of_scope') {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${notificationType}.out_of_scope`
             });
         }
         else if (classification === 'unknown') {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${notificationType || 'unknown'}.not_supported`
             });
         }
         await sendSafeAck(options.logger, options.sendNode, (0, pairing_1.buildNotificationAckNode)(node));
         if (notificationType === 'server_sync' && serverSyncCollections.length > 0) {
+            const collectionsCsv = serverSyncCollections.join(',');
             if (!options.syncAppState) {
                 options.logger.warn('received server_sync notification without app-state sync runtime', {
-                    collections: serverSyncCollections.join(',')
+                    collections: collectionsCsv
                 });
                 return true;
             }
             void options.syncAppState().catch((error) => {
                 options.logger.warn('failed to sync app-state after server_sync notification', {
-                    collections: serverSyncCollections.join(','),
+                    collections: collectionsCsv,
                     message: (0, primitives_1.toError)(error).message
                 });
             });
@@ -203,6 +205,7 @@ function createIncomingGroupNotificationHandler(options) {
         if (node.attrs.type !== constants_1.WA_NOTIFICATION_TYPES.GROUP) {
             return false;
         }
+        const baseEvent = createIncomingBaseEvent(node);
         const parsed = (0, group_1.parseGroupNotificationEvents)(node);
         for (const event of parsed.events) {
             options.emitGroupEvent(event);
@@ -212,7 +215,7 @@ function createIncomingGroupNotificationHandler(options) {
         }
         if (parsed.events.length === 0 && parsed.unhandled.length === 0) {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.empty`
             });
         }

package/dist/client/mailbox.js

@@ -4,14 +4,12 @@ exports.persistIncomingMailboxEntities = persistIncomingMailboxEntities;
 const _proto_1 = require("../proto.js");
 const primitives_1 = require("../util/primitives");
 async function persistContacts(contactStore, event, nowMs) {
-    const candidateJids = new Set();
-    if (event.senderJid) {
-        candidateJids.add(event.senderJid);
-    }
-    if (event.rawNode.attrs.participant) {
-        candidateJids.add(event.rawNode.attrs.participant);
+    const candidateJids = [event.senderJid, event.rawNode.attrs.participant].filter((jid) => !!jid);
+    if (candidateJids.length === 0) {
+        return;
     }
-    await Promise.all(Array.from(candidateJids, (jid) => contactStore.upsert({ jid, lastUpdatedMs: nowMs })));
+    const contacts = [...new Set(candidateJids)].map((jid) => ({ jid, lastUpdatedMs: nowMs }));
+    await contactStore.upsertBatch(contacts);
 }
 async function persistIncomingMailboxEntities(options) {
     const { logger, contactStore, messageStore, event } = options;
@@ -31,7 +29,9 @@ async function persistIncomingMailboxEntities(options) {
                 senderJid: event.senderJid,
                 participantJid: event.rawNode.attrs.participant,
                 fromMe: false,
-                timestampMs: event.timestampSeconds === undefined ? undefined : event.timestampSeconds * 1000,
+                timestampMs: event.timestampSeconds === undefined
+                    ? undefined
+                    : event.timestampSeconds * 1000,
                 encType: event.encryptionType,
                 plaintext: event.plaintext,
                 messageBytes

package/dist/client/messages.js

@@ -8,8 +8,8 @@ const WaMediaCrypto_1 = require("../media/WaMediaCrypto");
 const content_1 = require("../message/content");
 const constants_2 = require("../protocol/constants");
 const media_1 = require("../transport/node/builders/media");
-const base64_1 = require("../util/base64");
 const bytes_1 = require("../util/bytes");
+const bytes_2 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 async function buildMediaMessageContent(options, content) {
     if (typeof content === 'string') {
@@ -36,7 +36,7 @@ async function getMediaConn(options, forceRefresh = false) {
     return mediaConn;
 }
 async function buildMediaMessage(options, content) {
-    const mediaBytes = (0, bytes_1.toBytesView)(content.media);
+    const mediaBytes = (0, bytes_2.toBytesView)(content.media);
     const uploaded = await uploadMedia(options, content, mediaBytes);
     const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
     const common = {
@@ -113,7 +113,7 @@ async function uploadMedia(options, content, mediaBytes) {
     ]);
     const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ?? mediaConn.hosts[0].hostname;
     const uploadPath = constants_1.MEDIA_UPLOAD_PATHS[uploadType];
-    const hashToken = (0, base64_1.bytesToBase64UrlSafe)(encrypted.fileEncSha256);
+    const hashToken = (0, bytes_1.bytesToBase64UrlSafe)(encrypted.fileEncSha256);
     const uploadUrl = `https://${selectedHost}${uploadPath}/${hashToken}?auth=${encodeURIComponent(mediaConn.auth)}&token=${encodeURIComponent(hashToken)}`;
     options.logger.debug('sending media upload request', {
         mediaType: content.type,
@@ -133,7 +133,7 @@ async function uploadMedia(options, content, mediaBytes) {
     }
     let parsedBody;
     try {
-        parsedBody = JSON.parse(bytes_1.TEXT_DECODER.decode(uploadBody));
+        parsedBody = JSON.parse(bytes_2.TEXT_DECODER.decode(uploadBody));
     }
     catch (error) {
         throw new Error(`media upload returned invalid json: ${(0, primitives_1.toError)(error).message}`);

package/dist/client/messaging/fanout.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeviceFanoutResolver = createDeviceFanoutResolver;
+const jid_1 = require("../../protocol/jid");
+const primitives_1 = require("../../util/primitives");
+function createDeviceFanoutResolver(options) {
+    const { signalDeviceSync, getCurrentMeJid, getCurrentMeLid, logger } = options;
+    const requireCurrentMeJid = (context) => {
+        const meJid = getCurrentMeJid();
+        if (meJid) {
+            return meJid;
+        }
+        throw new Error(`${context} requires registered meJid`);
+    };
+    const resolveDirectFanoutDeviceJids = async (recipientJid, selfDeviceJidForRecipient) => {
+        const recipientUserJid = (0, jid_1.toUserJid)(recipientJid);
+        const meUserJid = (0, jid_1.toUserJid)(selfDeviceJidForRecipient);
+        const targets = recipientUserJid === meUserJid ? [recipientUserJid] : [recipientUserJid, meUserJid];
+        try {
+            const synced = await signalDeviceSync.syncDeviceList(targets);
+            const byUser = new Map(synced.map((entry) => [(0, jid_1.toUserJid)(entry.jid), entry.deviceJids]));
+            const fanout = new Set();
+            const recipientDevices = byUser.get(recipientUserJid) ?? [];
+            if (recipientDevices.length === 0) {
+                fanout.add(recipientUserJid);
+            }
+            else {
+                for (let index = 0; index < recipientDevices.length; index += 1) {
+                    fanout.add(recipientDevices[index]);
+                }
+            }
+            const meDevices = byUser.get(meUserJid) ?? [];
+            const normalizedMeJid = (0, jid_1.normalizeDeviceJid)(selfDeviceJidForRecipient);
+            for (let index = 0; index < meDevices.length; index += 1) {
+                const deviceJid = meDevices[index];
+                if ((0, jid_1.normalizeDeviceJid)(deviceJid) === normalizedMeJid) {
+                    continue;
+                }
+                fanout.add(deviceJid);
+            }
+            return [...fanout];
+        }
+        catch (error) {
+            logger.warn('signal device fanout sync failed, falling back to direct recipient', {
+                to: recipientJid,
+                message: (0, primitives_1.toError)(error).message
+            });
+            return [recipientUserJid];
+        }
+    };
+    const resolveGroupParticipantDeviceJids = async (participantUserJids) => {
+        const meDeviceJids = new Set();
+        const meJid = getCurrentMeJid();
+        if (meJid) {
+            try {
+                meDeviceJids.add((0, jid_1.normalizeDeviceJid)(meJid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me jid', {
+                    meJid,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        }
+        const meLid = getCurrentMeLid();
+        if (meLid && meLid.includes('@')) {
+            try {
+                meDeviceJids.add((0, jid_1.normalizeDeviceJid)(meLid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me lid jid', {
+                    meLid,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        }
+        const candidateUsers = [...new Set(participantUserJids)];
+        if (candidateUsers.length === 0) {
+            return [];
+        }
+        try {
+            const synced = await signalDeviceSync.syncDeviceList(candidateUsers);
+            const fanout = new Set();
+            for (const entry of synced) {
+                if (entry.deviceJids.length === 0) {
+                    const normalizedEntryJid = (0, jid_1.normalizeDeviceJid)(entry.jid);
+                    if (meDeviceJids.has(normalizedEntryJid)) {
+                        continue;
+                    }
+                    fanout.add(normalizedEntryJid);
+                    continue;
+                }
+                for (const deviceJid of entry.deviceJids) {
+                    const normalizedDeviceJid = (0, jid_1.normalizeDeviceJid)(deviceJid);
+                    if (meDeviceJids.has(normalizedDeviceJid)) {
+                        continue;
+                    }
+                    fanout.add(normalizedDeviceJid);
+                }
+            }
+            return [...fanout];
+        }
+        catch (error) {
+            logger.warn('group participant device sync failed, falling back to participant user jids', {
+                participants: candidateUsers.length,
+                message: (0, primitives_1.toError)(error).message
+            });
+            const fallbackJids = new Set();
+            for (const candidateJid of candidateUsers) {
+                try {
+                    const normalizedCandidateJid = (0, jid_1.normalizeDeviceJid)(candidateJid);
+                    if (meDeviceJids.has(normalizedCandidateJid)) {
+                        continue;
+                    }
+                    fallbackJids.add(normalizedCandidateJid);
+                }
+                catch (fallbackError) {
+                    logger.trace('ignoring malformed participant jid in fallback fanout resolution', {
+                        participantJid: candidateJid,
+                        message: (0, primitives_1.toError)(fallbackError).message
+                    });
+                }
+            }
+            return [...fallbackJids];
+        }
+    };
+    const resolveOwnPeerDeviceJids = async () => {
+        const meJid = requireCurrentMeJid('resolveOwnPeerDeviceJids');
+        const meUserJid = (0, jid_1.toUserJid)(meJid);
+        const meDevices = new Set();
+        meDevices.add((0, jid_1.normalizeDeviceJid)(meJid));
+        const meLid = getCurrentMeLid();
+        if (meLid && meLid.includes('@')) {
+            try {
+                meDevices.add((0, jid_1.normalizeDeviceJid)(meLid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me lid jid while resolving peer devices', {
+                    meLid,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        }
+        try {
+            const synced = await signalDeviceSync.syncDeviceList([meUserJid]);
+            const peerDevices = new Set();
+            for (const entry of synced) {
+                const sourceDevices = entry.deviceJids.length > 0 ? entry.deviceJids : [entry.jid];
+                for (const deviceJid of sourceDevices) {
+                    try {
+                        const normalized = (0, jid_1.normalizeDeviceJid)(deviceJid);
+                        if (meDevices.has(normalized)) {
+                            continue;
+                        }
+                        peerDevices.add(normalized);
+                    }
+                    catch (error) {
+                        logger.trace('ignoring malformed peer device jid while resolving app-state peers', {
+                            deviceJid,
+                            message: (0, primitives_1.toError)(error).message
+                        });
+                    }
+                }
+            }
+            return [...peerDevices];
+        }
+        catch (error) {
+            logger.warn('failed to resolve peer devices for app-state key request', {
+                message: (0, primitives_1.toError)(error).message
+            });
+            return [];
+        }
+    };
+    const resolveSelfDeviceJidForRecipient = (recipientJid, meJid, meLid) => {
+        if ((0, jid_1.splitJid)(recipientJid).server !== 'lid') {
+            return meJid;
+        }
+        if (!meLid || !meLid.includes('@')) {
+            return meJid;
+        }
+        return meLid;
+    };
+    return {
+        resolveDirectFanoutDeviceJids,
+        resolveGroupParticipantDeviceJids,
+        resolveOwnPeerDeviceJids,
+        resolveSelfDeviceJidForRecipient
+    };
+}

package/dist/client/messaging/key-protocol.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppStateSyncKeyProtocol = createAppStateSyncKeyProtocol;
+const padding_1 = require("../../message/padding");
+const _proto_1 = require("../../proto.js");
+const jid_1 = require("../../protocol/jid");
+const bytes_1 = require("../../util/bytes");
+function createAppStateSyncKeyProtocol(options) {
+    const { publishSignalMessage, fanoutResolver, getCurrentMeJid, getCurrentMeLid, logger } = options;
+    const requireCurrentIdentity = (context) => {
+        const meJid = getCurrentMeJid();
+        const meLid = getCurrentMeLid();
+        if (meJid || meLid) {
+            return;
+        }
+        throw new Error(`${context} requires registered identity`);
+    };
+    const publishProtocolMessageToDevice = async (deviceJid, protocolMessage) => {
+        const plaintext = await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode({
+            protocolMessage
+        }).finish());
+        await publishSignalMessage({
+            to: deviceJid,
+            plaintext,
+            type: 'protocol',
+            category: 'peer',
+            pushPriority: 'high'
+        });
+    };
+    const requestKeys = async (keyIds) => {
+        requireCurrentIdentity('requestKeys');
+        const normalizedKeyIds = [];
+        const seenKeyIds = new Set();
+        for (const keyId of keyIds) {
+            if (keyId.byteLength === 0) {
+                continue;
+            }
+            const keyHex = (0, bytes_1.bytesToHex)(keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            normalizedKeyIds.push(keyId);
+        }
+        if (normalizedKeyIds.length === 0) {
+            return [];
+        }
+        const peerDeviceJids = await fanoutResolver.resolveOwnPeerDeviceJids();
+        if (peerDeviceJids.length === 0) {
+            logger.warn('app-state sync key request skipped: no peer devices available', {
+                keys: normalizedKeyIds.length
+            });
+            return [];
+        }
+        const protocolMessage = {
+            type: _proto_1.proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST,
+            appStateSyncKeyRequest: {
+                keyIds: normalizedKeyIds.map((keyId) => ({
+                    keyId
+                }))
+            }
+        };
+        const publishResults = await Promise.allSettled(peerDeviceJids.map((deviceJid) => publishProtocolMessageToDevice(deviceJid, protocolMessage)));
+        const failedPublishes = publishResults.filter((result) => result.status === 'rejected').length;
+        if (failedPublishes > 0) {
+            logger.warn('some app-state sync key requests failed', {
+                total: peerDeviceJids.length,
+                failed: failedPublishes
+            });
+        }
+        logger.info('app-state sync key request sent to peer devices', {
+            devices: peerDeviceJids.length,
+            keys: normalizedKeyIds.length,
+            keyIds: normalizedKeyIds.map((keyId) => (0, bytes_1.bytesToHex)(keyId)).join(',')
+        });
+        return peerDeviceJids;
+    };
+    const sendKeyShare = async (toDeviceJid, keys, missingKeyIds = []) => {
+        requireCurrentIdentity('sendKeyShare');
+        const normalizedTo = (0, jid_1.normalizeDeviceJid)(toDeviceJid);
+        const seenKeyIds = new Set();
+        const keyShareEntries = [];
+        let sharedKeyCount = 0;
+        for (const key of keys) {
+            const keyHex = (0, bytes_1.bytesToHex)(key.keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            sharedKeyCount += 1;
+            keyShareEntries.push({
+                keyId: { keyId: key.keyId },
+                keyData: {
+                    keyData: key.keyData,
+                    timestamp: key.timestamp,
+                    ...(key.fingerprint ? { fingerprint: key.fingerprint } : {})
+                }
+            });
+        }
+        for (const keyId of missingKeyIds) {
+            if (keyId.byteLength === 0) {
+                continue;
+            }
+            const keyHex = (0, bytes_1.bytesToHex)(keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            keyShareEntries.push({
+                keyId: { keyId }
+            });
+        }
+        const protocolMessage = {
+            type: _proto_1.proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE,
+            appStateSyncKeyShare: {
+                keys: keyShareEntries
+            }
+        };
+        await publishProtocolMessageToDevice(normalizedTo, protocolMessage);
+        logger.info('app-state sync key share sent', {
+            to: normalizedTo,
+            keys: sharedKeyCount,
+            orphanKeys: keyShareEntries.length - sharedKeyCount
+        });
+    };
+    return {
+        requestKeys,
+        sendKeyShare
+    };
+}