zapo-js 0.1.2 → 0.3.0

package/dist/client/dirty.js

@@ -28,7 +28,13 @@ function parseDirtyBitNode(node, logger) {
     };
 }
 function resolveAccountSyncProtocols(protocols) {
-    const selected = protocols.filter((protocol) => ACCOUNT_SYNC_PROTOCOL_SET.has(protocol));
+    const selected = [];
+    for (let index = 0; index < protocols.length; index += 1) {
+        const protocol = protocols[index];
+        if (ACCOUNT_SYNC_PROTOCOL_SET.has(protocol)) {
+            selected.push(protocol);
+        }
+    }
     if (selected.length > 0) {
         return selected;
     }
@@ -60,12 +66,24 @@ async function handleDirtyBits(runtime, dirtyBits) {
         }
         unsupported.push(dirtyBit);
     }
+    const supportedTypes = new Array(supported.length);
+    for (let index = 0; index < supported.length; index += 1) {
+        supportedTypes[index] = supported[index].type;
+    }
+    const unsupportedTypes = new Array(unsupported.length);
+    for (let index = 0; index < unsupported.length; index += 1) {
+        unsupportedTypes[index] = unsupported[index].type;
+    }
     runtime.logger.info('handling dirty bits from info bulletin', {
-        supported: supported.map((entry) => entry.type).join(','),
-        unsupported: unsupported.map((entry) => entry.type).join(',')
+        supported: supportedTypes.join(','),
+        unsupported: unsupportedTypes.join(',')
     });
     const clearableDirtyBits = [...unsupported];
-    const settledSupported = await Promise.allSettled(supported.map(async (dirtyBit) => handleDirtyBit(runtime, dirtyBit)));
+    const supportedPromises = new Array(supported.length);
+    for (let index = 0; index < supported.length; index += 1) {
+        supportedPromises[index] = handleDirtyBit(runtime, supported[index]);
+    }
+    const settledSupported = await Promise.allSettled(supportedPromises);
     for (let index = 0; index < settledSupported.length; index += 1) {
         const result = settledSupported[index];
         if (result.status === 'fulfilled') {
@@ -105,18 +123,23 @@ async function handleAccountSyncDirtyBit(runtime, protocols) {
         protocols: selectedProtocols.join(',')
     });
     const failures = [];
-    await Promise.all(selectedProtocols.map(async (protocol) => {
-        try {
-            await runAccountSyncProtocol(runtime, protocol);
-        }
-        catch (error) {
-            failures.push(protocol);
-            runtime.logger.warn('account_sync protocol failed', {
-                protocol,
-                message: (0, primitives_1.toError)(error).message
-            });
-        }
-    }));
+    const protocolPromises = new Array(selectedProtocols.length);
+    for (let index = 0; index < selectedProtocols.length; index += 1) {
+        const protocol = selectedProtocols[index];
+        protocolPromises[index] = (async () => {
+            try {
+                await runAccountSyncProtocol(runtime, protocol);
+            }
+            catch (error) {
+                failures.push(protocol);
+                runtime.logger.warn('account_sync protocol failed', {
+                    protocol,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        })();
+    }
+    await Promise.all(protocolPromises);
     if (failures.length > 0) {
         throw new Error(`account_sync protocols failed: ${failures.join(',')}`);
     }
@@ -136,7 +159,7 @@ async function runAccountSyncProtocol(runtime, protocol) {
             await syncAccountBlocklistDirtyBit(runtime);
             return;
         case constants_1.WA_DIRTY_PROTOCOLS.NOTICE:
-            await syncAccountNoticeDirtyBit(runtime);
+            runtime.logger.info('account_sync notice protocol received (no GraphQL/MEX job configured)');
             return;
         default:
             runtime.logger.debug('unsupported account_sync protocol', {
@@ -211,9 +234,6 @@ async function syncAccountBlocklistDirtyBit(runtime) {
         logMessage: 'account_sync blocklist synchronized'
     });
 }
-async function syncAccountNoticeDirtyBit(runtime) {
-    runtime.logger.info('account_sync notice protocol received (no GraphQL/MEX job configured)');
-}
 async function syncGroupsDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'dirty.groups',
@@ -246,7 +266,7 @@ async function clearDirtyBits(runtime, dirtyBits) {
     try {
         await runtime.queryWithContext('dirty.clear', (0, account_sync_1.buildClearDirtyBitsIq)(dirtyBits), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: dirtyBits.length
-        });
+        }, { useSystemId: true });
         runtime.logger.info('dirty bits cleared', {
             count: dirtyBits.length
         });

package/dist/client/events/abprops.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAbPropsIqResult = parseAbPropsIqResult;
+const helpers_1 = require("../../transport/node/helpers");
+const primitives_1 = require("../../util/primitives");
+function parseAbPropsIqResult(node) {
+    const propsNode = (0, helpers_1.findNodeChild)(node, 'props');
+    if (!propsNode) {
+        return {
+            abKey: null,
+            hash: null,
+            refresh: null,
+            refreshId: null,
+            isDeltaUpdate: false,
+            props: []
+        };
+    }
+    const attrs = propsNode.attrs;
+    const propChildren = (0, helpers_1.getNodeChildren)(propsNode);
+    const props = [];
+    for (let i = 0; i < propChildren.length; i += 1) {
+        const child = propChildren[i];
+        if (child.tag !== 'prop') {
+            continue;
+        }
+        const configCode = (0, primitives_1.parseOptionalInt)(child.attrs.config_code);
+        if (configCode === undefined) {
+            continue;
+        }
+        props.push({
+            configCode,
+            configValue: child.attrs.config_value ?? null
+        });
+    }
+    return {
+        abKey: attrs.ab_key ?? null,
+        hash: attrs.hash ?? null,
+        refresh: (0, primitives_1.parseOptionalInt)(attrs.refresh) ?? null,
+        refreshId: (0, primitives_1.parseOptionalInt)(attrs.refresh_id) ?? null,
+        isDeltaUpdate: attrs.delta_update === 'true',
+        props
+    };
+}

package/dist/client/events/devices.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEVICE_NOTIFICATION_ACTIONS = void 0;
+exports.parseDeviceNotification = parseDeviceNotification;
+const jid_1 = require("../../protocol/jid");
+const helpers_1 = require("../../transport/node/helpers");
+exports.DEVICE_NOTIFICATION_ACTIONS = Object.freeze({
+    ADD: 'add',
+    REMOVE: 'remove',
+    UPDATE: 'update'
+});
+function parseDeviceNotification(node) {
+    const stanzaId = node.attrs.id;
+    const fromJid = node.attrs.from;
+    if (!stanzaId || !fromJid) {
+        return null;
+    }
+    let action;
+    let actionNode;
+    if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE);
+    }
+    else if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.ADD)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.ADD;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.ADD);
+    }
+    else if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE);
+    }
+    else {
+        return null;
+    }
+    const devices = [];
+    if (action !== exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE && actionNode) {
+        const deviceNodes = (0, helpers_1.getNodeChildrenByTag)(actionNode, 'device');
+        for (let index = 0; index < deviceNodes.length; index += 1) {
+            const deviceNode = deviceNodes[index];
+            const jidAttr = deviceNode.attrs.jid;
+            if (!jidAttr) {
+                continue;
+            }
+            let deviceId;
+            try {
+                deviceId = (0, jid_1.parseSignalAddressFromJid)(jidAttr).device;
+            }
+            catch {
+                continue;
+            }
+            const keyIndexAttr = deviceNode.attrs['key-index'];
+            const parsedKeyIndex = keyIndexAttr === undefined ? null : Number.parseInt(keyIndexAttr, 10);
+            const keyIndex = parsedKeyIndex !== null &&
+                Number.isSafeInteger(parsedKeyIndex) &&
+                parsedKeyIndex >= 0
+                ? parsedKeyIndex
+                : null;
+            devices[devices.length] = {
+                deviceId,
+                keyIndex
+            };
+        }
+    }
+    return {
+        action,
+        stanzaId,
+        fromJid,
+        lid: node.attrs.lid,
+        hash: action === exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE ? actionNode?.attrs.hash : undefined,
+        devices
+    };
+}

package/dist/client/events/group.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseParticipants = parseParticipants;
 exports.parseGroupNotificationEvents = parseGroupNotificationEvents;
+const incoming_1 = require("../incoming");
 const constants_1 = require("../../protocol/constants");
 const nodes_1 = require("../../protocol/nodes");
 const helpers_1 = require("../../transport/node/helpers");
@@ -103,15 +104,6 @@ function createBaseGroupEvent(notificationNode, actionNode) {
         timestampSeconds: (0, primitives_1.parseOptionalInt)(notificationNode.attrs.t)
     };
 }
-function createUnhandledStanzaEvent(notificationNode, reason) {
-    return {
-        rawNode: notificationNode,
-        stanzaId: notificationNode.attrs.id,
-        chatJid: notificationNode.attrs.from,
-        stanzaType: notificationNode.attrs.type,
-        reason
-    };
-}
 function parseCreateGroupAction(notificationNode, actionNode) {
     const groupNode = (0, helpers_1.findNodeChild)(actionNode, nodes_1.WA_NODE_TAGS.GROUP);
     if (!groupNode) {
@@ -417,13 +409,13 @@ function parseGroupNotificationEvents(notificationNode) {
         try {
             const parsedEvent = parseGroupActionNode(notificationNode, actionNode);
             if (!parsedEvent) {
-                unhandled.push(createUnhandledStanzaEvent(notificationNode, `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.not_supported`));
+                unhandled.push((0, incoming_1.createUnhandledIncomingNodeEvent)(notificationNode, `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.not_supported`));
                 continue;
             }
             events.push(parsedEvent);
         }
         catch {
-            unhandled.push(createUnhandledStanzaEvent(notificationNode, `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.parse_failed`));
+            unhandled.push((0, incoming_1.createUnhandledIncomingNodeEvent)(notificationNode, `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.parse_failed`));
         }
     }
     return {

package/dist/client/events/identity.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIdentityChangeNotification = parseIdentityChangeNotification;
+const helpers_1 = require("../../transport/node/helpers");
+function parseIdentityChangeNotification(node) {
+    const child = (0, helpers_1.getFirstNodeChild)(node);
+    if (!child || child.tag !== 'identity') {
+        return null;
+    }
+    const fromJid = node.attrs.from;
+    const stanzaId = node.attrs.id;
+    if (!fromJid || !stanzaId) {
+        return null;
+    }
+    return {
+        fromJid,
+        stanzaId,
+        displayName: node.attrs.display_name,
+        lid: node.attrs.lid,
+        offline: node.attrs.offline
+    };
+}

package/dist/client/events/privacy-token.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrivacyTokenNotification = parsePrivacyTokenNotification;
+const privacy_token_1 = require("../../protocol/privacy-token");
+const helpers_1 = require("../../transport/node/helpers");
+const coercion_1 = require("../../util/coercion");
+function parsePrivacyTokenNotification(node) {
+    const tokensNode = (0, helpers_1.findNodeChild)(node, privacy_token_1.WA_PRIVACY_TOKEN_TAGS.TOKENS);
+    if (!tokensNode) {
+        return [];
+    }
+    const children = (0, helpers_1.getNodeChildren)(tokensNode);
+    const result = [];
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child.tag !== privacy_token_1.WA_PRIVACY_TOKEN_TAGS.TOKEN) {
+            continue;
+        }
+        const type = child.attrs.type;
+        if (!type) {
+            continue;
+        }
+        const rawTimestamp = child.attrs.t;
+        if (!rawTimestamp) {
+            continue;
+        }
+        const content = child.content;
+        if (!(content instanceof Uint8Array)) {
+            continue;
+        }
+        result[result.length] = {
+            type,
+            tokenBytes: content,
+            timestampS: (0, coercion_1.asNumber)(Number(rawTimestamp), 'privacy_token.t')
+        };
+    }
+    return result;
+}

package/dist/client/events/registration.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRegistrationNotification = parseRegistrationNotification;
+const notification_1 = require("../../protocol/notification");
+const helpers_1 = require("../../transport/node/helpers");
+const primitives_1 = require("../../util/primitives");
+function parseRegistrationNotification(node) {
+    const firstChild = (0, helpers_1.getFirstNodeChild)(node);
+    if (!firstChild) {
+        return null;
+    }
+    if (firstChild.tag === notification_1.WA_REGISTRATION_NOTIFICATION_TAGS.WA_OLD_REGISTRATION) {
+        const code = firstChild.attrs.code;
+        const expirySeconds = (0, primitives_1.parseOptionalInt)(firstChild.attrs.expiry_t);
+        const fromDeviceId = firstChild.attrs.device_id;
+        if (!code || expirySeconds === undefined || !fromDeviceId) {
+            return null;
+        }
+        return {
+            kind: 'registration_code',
+            code,
+            expiryTimestampMs: expirySeconds * 1000,
+            fromDeviceId
+        };
+    }
+    if (firstChild.tag === notification_1.WA_REGISTRATION_NOTIFICATION_TAGS.DEVICE_LOGOUT) {
+        const serverToken = firstChild.attrs.id;
+        const tSeconds = (0, primitives_1.parseOptionalInt)(firstChild.attrs.t);
+        if (!serverToken || tSeconds === undefined) {
+            return null;
+        }
+        return {
+            kind: 'account_takeover_notice',
+            serverToken,
+            attemptTimestampMs: tSeconds * 1000,
+            newDeviceName: firstChild.attrs.device,
+            newDevicePlatform: firstChild.attrs.new_device_platform,
+            newDeviceAppVersion: firstChild.attrs.new_device_app_version
+        };
+    }
+    return null;
+}

package/dist/client/history-sync.js

@@ -13,6 +13,7 @@ const HANDLED_SYNC_TYPES = new Set([
     _proto_1.proto.Message.HistorySyncType.FULL,
     _proto_1.proto.Message.HistorySyncType.PUSH_NAME
 ]);
+const HISTORY_SYNC_MAX_PENDING_WRITES = 1024;
 async function processHistorySyncNotification(deps, notification) {
     const syncType = notification.syncType;
     if (syncType === null || syncType === undefined || !HANDLED_SYNC_TYPES.has(syncType)) {
@@ -30,19 +31,20 @@ async function processHistorySyncNotification(deps, notification) {
         pushnames: historySync.pushnames.length
     });
     const nowMs = Date.now();
-    const contacts = [];
+    const pendingWrites = [];
     for (const pn of historySync.pushnames) {
         if (!pn.id) {
             continue;
         }
-        contacts.push({
+        pendingWrites[pendingWrites.length] = deps.writeBehind.persistContactAsync({
             jid: pn.id,
             pushName: pn.pushname ?? undefined,
             lastUpdatedMs: nowMs
         });
+        if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+            await flushPendingWrites(pendingWrites);
+        }
     }
-    const threads = [];
-    const messages = [];
     let messagesCount = 0;
     for (const conversation of historySync.conversations) {
         const threadJid = conversation.id;
@@ -50,7 +52,7 @@ async function processHistorySyncNotification(deps, notification) {
             deps.logger.debug('skipping history sync conversation without thread jid');
             continue;
         }
-        threads.push({
+        pendingWrites[pendingWrites.length] = deps.writeBehind.persistThreadAsync({
             jid: threadJid,
             name: conversation.name ?? undefined,
             unreadCount: conversation.unreadCount ?? undefined,
@@ -60,13 +62,16 @@ async function processHistorySyncNotification(deps, notification) {
             markedAsUnread: conversation.markedAsUnread ?? undefined,
             ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
         });
+        if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+            await flushPendingWrites(pendingWrites);
+        }
         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({
+            pendingWrites[pendingWrites.length] = deps.writeBehind.persistMessageAsync({
                 id: webMsg.key.id,
                 threadJid,
                 senderJid: webMsg.key.participant ?? undefined,
@@ -76,12 +81,35 @@ async function processHistorySyncNotification(deps, notification) {
                     ? _proto_1.proto.Message.encode(webMsg.message).finish()
                     : undefined
             });
+            if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+                await flushPendingWrites(pendingWrites);
+            }
             messagesCount += 1;
         }
     }
-    await deps.contactStore.upsertBatch(contacts);
-    await deps.threadStore.upsertBatch(threads);
-    await deps.messageStore.upsertBatch(messages);
+    if (deps.onPrivacyTokens) {
+        const tokenConversations = [];
+        for (const conversation of historySync.conversations) {
+            if (!conversation.id)
+                continue;
+            if (conversation.tcToken ||
+                conversation.tcTokenTimestamp ||
+                conversation.tcTokenSenderTimestamp) {
+                tokenConversations[tokenConversations.length] = {
+                    jid: conversation.id,
+                    tcToken: conversation.tcToken,
+                    tcTokenTimestamp: (0, primitives_1.longToNumber)(conversation.tcTokenTimestamp) || undefined,
+                    tcTokenSenderTimestamp: (0, primitives_1.longToNumber)(conversation.tcTokenSenderTimestamp) || undefined
+                };
+            }
+        }
+        if (tokenConversations.length > 0) {
+            pendingWrites[pendingWrites.length] = deps.onPrivacyTokens(tokenConversations);
+        }
+    }
+    if (deps.onNctSalt && historySync.nctSalt) {
+        pendingWrites[pendingWrites.length] = deps.onNctSalt(historySync.nctSalt);
+    }
     const event = {
         syncType,
         messagesCount,
@@ -90,8 +118,21 @@ async function processHistorySyncNotification(deps, notification) {
         chunkOrder: historySync.chunkOrder ?? undefined,
         progress: historySync.progress ?? undefined
     };
+    await flushPendingWrites(pendingWrites);
     deps.emitEvent('history_sync_chunk', event);
 }
+async function flushPendingWrites(pendingWrites) {
+    if (pendingWrites.length === 0) {
+        return;
+    }
+    const pendingCount = pendingWrites.length;
+    const batch = new Array(pendingCount);
+    for (let index = 0; index < pendingCount; index += 1) {
+        batch[index] = pendingWrites[index];
+    }
+    pendingWrites.length = 0;
+    await Promise.all(batch);
+}
 async function downloadHistorySyncBlob(deps, notification) {
     if (notification.initialHistBootstrapInlinePayload) {
         return (0, bytes_1.decodeProtoBytes)(notification.initialHistBootstrapInlinePayload, 'initialHistBootstrapInlinePayload');

package/dist/client/incoming.js

@@ -4,15 +4,24 @@ exports.createIncomingBaseEvent = createIncomingBaseEvent;
 exports.createIncomingReceiptHandler = createIncomingReceiptHandler;
 exports.createIncomingFailureHandler = createIncomingFailureHandler;
 exports.createIncomingNotificationHandler = createIncomingNotificationHandler;
+exports.createIncomingRegistrationNotificationHandler = createIncomingRegistrationNotificationHandler;
 exports.createIncomingGroupNotificationHandler = createIncomingGroupNotificationHandler;
 exports.createInfoBulletinNotificationEvent = createInfoBulletinNotificationEvent;
 exports.createUnhandledIncomingNodeEvent = createUnhandledIncomingNodeEvent;
 const group_1 = require("./events/group");
+const registration_1 = require("./events/registration");
 const constants_1 = require("../protocol/constants");
-const message_1 = require("../transport/node/builders/message");
-const pairing_1 = require("../transport/node/builders/pairing");
+const global_1 = require("../transport/node/builders/global");
 const helpers_1 = require("../transport/node/helpers");
 const primitives_1 = require("../util/primitives");
+const FAILURE_REASON_TO_DISCONNECT = {
+    401: constants_1.WA_DISCONNECT_REASONS.FAILURE_NOT_AUTHORIZED,
+    403: constants_1.WA_DISCONNECT_REASONS.FAILURE_LOCKED,
+    406: constants_1.WA_DISCONNECT_REASONS.FAILURE_BANNED,
+    405: constants_1.WA_DISCONNECT_REASONS.FAILURE_CLIENT_TOO_OLD,
+    409: constants_1.WA_DISCONNECT_REASONS.FAILURE_BAD_USER_AGENT,
+    503: constants_1.WA_DISCONNECT_REASONS.FAILURE_SERVICE_UNAVAILABLE
+};
 const LOGOUT_FAILURE_REASONS = new Set([401, 403, 406]);
 const DISCONNECT_FAILURE_REASONS = new Set([405, 409, 503]);
 const CORE_NOTIFICATION_TYPES = new Set([
@@ -39,6 +48,8 @@ const OUT_OF_SCOPE_NOTIFICATION_TYPES = new Set([
     'waffle',
     'hosted'
 ]);
+const NOTIFICATION_TYPES_WITH_PARTICIPANT_ACK = new Set(['mediaretry', 'psa']);
+const NOTIFICATION_TYPES_WITHOUT_TYPE_ACK = new Set(['encrypt', 'devices']);
 function createIncomingBaseEvent(node) {
     return {
         rawNode: node,
@@ -72,7 +83,9 @@ function classifyNotificationType(notificationType) {
 }
 async function applyFailureAction(options, reason, clearStoredCredentials) {
     try {
-        await options.disconnect();
+        options.stopComms();
+        const disconnectReason = FAILURE_REASON_TO_DISCONNECT[reason] ?? constants_1.WA_DISCONNECT_REASONS.STREAM_ERROR_OTHER;
+        await options.disconnect(disconnectReason, clearStoredCredentials, reason);
         if (clearStoredCredentials) {
             await options.clearStoredCredentials();
         }
@@ -117,11 +130,19 @@ function createIncomingReceiptHandler(options) {
                 await options.handleIncomingRetryReceipt(node);
             }
             else {
-                await sendSafeAck(options.logger, options.sendNode, (0, message_1.buildInboundRetryReceiptAckNode)(node));
+                await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+                    kind: 'receipt',
+                    node,
+                    retryType: true
+                }));
             }
             return true;
         }
-        await sendSafeAck(options.logger, options.sendNode, (0, message_1.buildInboundReceiptAckNode)(node));
+        await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+            kind: 'receipt',
+            node,
+            includeParticipant: receiptType !== 'server-error'
+        }));
         return true;
     };
 }
@@ -147,6 +168,8 @@ function createIncomingFailureHandler(options) {
 function createIncomingNotificationHandler(options) {
     return async (node) => {
         const notificationType = node.attrs.type ?? '';
+        const includeParticipantInAck = NOTIFICATION_TYPES_WITH_PARTICIPANT_ACK.has(notificationType);
+        const includeTypeInAck = !NOTIFICATION_TYPES_WITHOUT_TYPE_ACK.has(notificationType);
         const classification = classifyNotificationType(notificationType);
         const firstChildTag = (0, helpers_1.getFirstNodeChild)(node)?.tag;
         const baseEvent = createIncomingBaseEvent(node);
@@ -181,7 +204,12 @@ function createIncomingNotificationHandler(options) {
                 reason: `notification.${notificationType || 'unknown'}.not_supported`
             });
         }
-        await sendSafeAck(options.logger, options.sendNode, (0, pairing_1.buildNotificationAckNode)(node));
+        await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+            kind: 'notification',
+            node,
+            includeParticipant: includeParticipantInAck,
+            includeType: includeTypeInAck
+        }));
         if (notificationType === 'server_sync' && serverSyncCollections.length > 0) {
             const collectionsCsv = serverSyncCollections.join(',');
             if (!options.syncAppState) {
@@ -200,6 +228,41 @@ function createIncomingNotificationHandler(options) {
         return true;
     };
 }
+function createIncomingRegistrationNotificationHandler(options) {
+    return async (node) => {
+        if (node.attrs.type !== constants_1.WA_NOTIFICATION_TYPES.REGISTRATION) {
+            return false;
+        }
+        const parsed = (0, registration_1.parseRegistrationNotification)(node);
+        if (!parsed) {
+            return false;
+        }
+        const baseEvent = createIncomingBaseEvent(node);
+        if (parsed.kind === 'registration_code') {
+            options.emitRegistrationCode({
+                ...baseEvent,
+                code: parsed.code,
+                expiryTimestampMs: parsed.expiryTimestampMs,
+                fromDeviceId: parsed.fromDeviceId
+            });
+        }
+        else {
+            options.emitAccountTakeoverNotice({
+                ...baseEvent,
+                serverToken: parsed.serverToken,
+                attemptTimestampMs: parsed.attemptTimestampMs,
+                newDeviceName: parsed.newDeviceName,
+                newDevicePlatform: parsed.newDevicePlatform,
+                newDeviceAppVersion: parsed.newDeviceAppVersion
+            });
+        }
+        await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+            kind: 'notification',
+            node
+        }));
+        return true;
+    };
+}
 function createIncomingGroupNotificationHandler(options) {
     return async (node) => {
         if (node.attrs.type !== constants_1.WA_NOTIFICATION_TYPES.GROUP) {
@@ -219,7 +282,11 @@ function createIncomingGroupNotificationHandler(options) {
                 reason: `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.empty`
             });
         }
-        await sendSafeAck(options.logger, options.sendNode, (0, pairing_1.buildNotificationAckNode)(node));
+        await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+            kind: 'notification',
+            node,
+            includeParticipant: true
+        }));
         return true;
     };
 }