zapo-js 0.1.2 → 0.3.0

package/dist/esm/client/dirty.js

@@ -24,7 +24,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;
     }
@@ -56,12 +62,24 @@ export 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') {
@@ -101,18 +119,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: 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: toError(error).message
+                });
+            }
+        })();
+    }
+    await Promise.all(protocolPromises);
     if (failures.length > 0) {
         throw new Error(`account_sync protocols failed: ${failures.join(',')}`);
     }
@@ -132,7 +155,7 @@ async function runAccountSyncProtocol(runtime, protocol) {
             await syncAccountBlocklistDirtyBit(runtime);
             return;
         case 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', {
@@ -207,9 +230,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',
@@ -242,7 +262,7 @@ async function clearDirtyBits(runtime, dirtyBits) {
     try {
         await runtime.queryWithContext('dirty.clear', buildClearDirtyBitsIq(dirtyBits), WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: dirtyBits.length
-        });
+        }, { useSystemId: true });
         runtime.logger.info('dirty bits cleared', {
             count: dirtyBits.length
         });

package/dist/esm/client/events/abprops.js

@@ -0,0 +1,40 @@
+import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+export function parseAbPropsIqResult(node) {
+    const propsNode = findNodeChild(node, 'props');
+    if (!propsNode) {
+        return {
+            abKey: null,
+            hash: null,
+            refresh: null,
+            refreshId: null,
+            isDeltaUpdate: false,
+            props: []
+        };
+    }
+    const attrs = propsNode.attrs;
+    const propChildren = getNodeChildren(propsNode);
+    const props = [];
+    for (let i = 0; i < propChildren.length; i += 1) {
+        const child = propChildren[i];
+        if (child.tag !== 'prop') {
+            continue;
+        }
+        const configCode = 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: parseOptionalInt(attrs.refresh) ?? null,
+        refreshId: parseOptionalInt(attrs.refresh_id) ?? null,
+        isDeltaUpdate: attrs.delta_update === 'true',
+        props
+    };
+}

package/dist/esm/client/events/devices.js

@@ -0,0 +1,68 @@
+import { parseSignalAddressFromJid } from '../../protocol/jid.js';
+import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+export const DEVICE_NOTIFICATION_ACTIONS = Object.freeze({
+    ADD: 'add',
+    REMOVE: 'remove',
+    UPDATE: 'update'
+});
+export function parseDeviceNotification(node) {
+    const stanzaId = node.attrs.id;
+    const fromJid = node.attrs.from;
+    if (!stanzaId || !fromJid) {
+        return null;
+    }
+    let action;
+    let actionNode;
+    if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.REMOVE)) {
+        action = DEVICE_NOTIFICATION_ACTIONS.REMOVE;
+        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.REMOVE);
+    }
+    else if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.ADD)) {
+        action = DEVICE_NOTIFICATION_ACTIONS.ADD;
+        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.ADD);
+    }
+    else if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.UPDATE)) {
+        action = DEVICE_NOTIFICATION_ACTIONS.UPDATE;
+        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.UPDATE);
+    }
+    else {
+        return null;
+    }
+    const devices = [];
+    if (action !== DEVICE_NOTIFICATION_ACTIONS.UPDATE && actionNode) {
+        const deviceNodes = 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 = 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 === DEVICE_NOTIFICATION_ACTIONS.UPDATE ? actionNode?.attrs.hash : undefined,
+        devices
+    };
+}

package/dist/esm/client/events/group.js

@@ -1,3 +1,4 @@
+import { createUnhandledIncomingNodeEvent } from '../incoming.js';
 import { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from '../../protocol/constants.js';
 import { WA_NODE_TAGS } from '../../protocol/nodes.js';
 import { findNodeChild, getNodeChildren, getNodeChildrenByTag } from '../../transport/node/helpers.js';
@@ -99,15 +100,6 @@ function createBaseGroupEvent(notificationNode, actionNode) {
         timestampSeconds: 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 = findNodeChild(actionNode, WA_NODE_TAGS.GROUP);
     if (!groupNode) {
@@ -413,13 +405,13 @@ export function parseGroupNotificationEvents(notificationNode) {
         try {
             const parsedEvent = parseGroupActionNode(notificationNode, actionNode);
             if (!parsedEvent) {
-                unhandled.push(createUnhandledStanzaEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.not_supported`));
+                unhandled.push(createUnhandledIncomingNodeEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.not_supported`));
                 continue;
             }
             events.push(parsedEvent);
         }
         catch {
-            unhandled.push(createUnhandledStanzaEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.parse_failed`));
+            unhandled.push(createUnhandledIncomingNodeEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.parse_failed`));
         }
     }
     return {

package/dist/esm/client/events/identity.js

@@ -0,0 +1,19 @@
+import { getFirstNodeChild } from '../../transport/node/helpers.js';
+export function parseIdentityChangeNotification(node) {
+    const child = 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/esm/client/events/privacy-token.js

@@ -0,0 +1,35 @@
+import { WA_PRIVACY_TOKEN_TAGS } from '../../protocol/privacy-token.js';
+import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { asNumber } from '../../util/coercion.js';
+export function parsePrivacyTokenNotification(node) {
+    const tokensNode = findNodeChild(node, WA_PRIVACY_TOKEN_TAGS.TOKENS);
+    if (!tokensNode) {
+        return [];
+    }
+    const children = getNodeChildren(tokensNode);
+    const result = [];
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child.tag !== 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: asNumber(Number(rawTimestamp), 'privacy_token.t')
+        };
+    }
+    return result;
+}

package/dist/esm/client/events/registration.js

@@ -0,0 +1,39 @@
+import { WA_REGISTRATION_NOTIFICATION_TAGS } from '../../protocol/notification.js';
+import { getFirstNodeChild } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+export function parseRegistrationNotification(node) {
+    const firstChild = getFirstNodeChild(node);
+    if (!firstChild) {
+        return null;
+    }
+    if (firstChild.tag === WA_REGISTRATION_NOTIFICATION_TAGS.WA_OLD_REGISTRATION) {
+        const code = firstChild.attrs.code;
+        const expirySeconds = 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 === WA_REGISTRATION_NOTIFICATION_TAGS.DEVICE_LOGOUT) {
+        const serverToken = firstChild.attrs.id;
+        const tSeconds = 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/esm/client/history-sync.js

@@ -10,6 +10,7 @@ const HANDLED_SYNC_TYPES = new Set([
     proto.Message.HistorySyncType.FULL,
     proto.Message.HistorySyncType.PUSH_NAME
 ]);
+const HISTORY_SYNC_MAX_PENDING_WRITES = 1024;
 export async function processHistorySyncNotification(deps, notification) {
     const syncType = notification.syncType;
     if (syncType === null || syncType === undefined || !HANDLED_SYNC_TYPES.has(syncType)) {
@@ -27,19 +28,20 @@ export 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;
@@ -47,7 +49,7 @@ export 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,
@@ -57,13 +59,16 @@ export 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 = longToNumber(webMsg.messageTimestamp) * 1000;
-            messages.push({
+            pendingWrites[pendingWrites.length] = deps.writeBehind.persistMessageAsync({
                 id: webMsg.key.id,
                 threadJid,
                 senderJid: webMsg.key.participant ?? undefined,
@@ -73,12 +78,35 @@ export async function processHistorySyncNotification(deps, notification) {
                     ? 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: longToNumber(conversation.tcTokenTimestamp) || undefined,
+                    tcTokenSenderTimestamp: 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,
@@ -87,8 +115,21 @@ export 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 decodeProtoBytes(notification.initialHistBootstrapInlinePayload, 'initialHistBootstrapInlinePayload');

package/dist/esm/client/incoming.js

@@ -1,9 +1,17 @@
 import { parseGroupNotificationEvents } from './events/group.js';
-import { WA_NODE_TAGS, WA_NOTIFICATION_TYPES } from '../protocol/constants.js';
-import { buildInboundReceiptAckNode, buildInboundRetryReceiptAckNode } from '../transport/node/builders/message.js';
-import { buildNotificationAckNode } from '../transport/node/builders/pairing.js';
+import { parseRegistrationNotification } from './events/registration.js';
+import { WA_DISCONNECT_REASONS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES } from '../protocol/constants.js';
+import { buildAckNode } from '../transport/node/builders/global.js';
 import { getFirstNodeChild, getNodeChildrenNonEmptyAttrValuesByTag } from '../transport/node/helpers.js';
 import { parseOptionalInt, toError } from '../util/primitives.js';
+const FAILURE_REASON_TO_DISCONNECT = {
+    401: WA_DISCONNECT_REASONS.FAILURE_NOT_AUTHORIZED,
+    403: WA_DISCONNECT_REASONS.FAILURE_LOCKED,
+    406: WA_DISCONNECT_REASONS.FAILURE_BANNED,
+    405: WA_DISCONNECT_REASONS.FAILURE_CLIENT_TOO_OLD,
+    409: WA_DISCONNECT_REASONS.FAILURE_BAD_USER_AGENT,
+    503: 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([
@@ -30,6 +38,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']);
 export function createIncomingBaseEvent(node) {
     return {
         rawNode: node,
@@ -63,7 +73,9 @@ function classifyNotificationType(notificationType) {
 }
 async function applyFailureAction(options, reason, clearStoredCredentials) {
     try {
-        await options.disconnect();
+        options.stopComms();
+        const disconnectReason = FAILURE_REASON_TO_DISCONNECT[reason] ?? WA_DISCONNECT_REASONS.STREAM_ERROR_OTHER;
+        await options.disconnect(disconnectReason, clearStoredCredentials, reason);
         if (clearStoredCredentials) {
             await options.clearStoredCredentials();
         }
@@ -108,11 +120,19 @@ export function createIncomingReceiptHandler(options) {
                 await options.handleIncomingRetryReceipt(node);
             }
             else {
-                await sendSafeAck(options.logger, options.sendNode, buildInboundRetryReceiptAckNode(node));
+                await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+                    kind: 'receipt',
+                    node,
+                    retryType: true
+                }));
             }
             return true;
         }
-        await sendSafeAck(options.logger, options.sendNode, buildInboundReceiptAckNode(node));
+        await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+            kind: 'receipt',
+            node,
+            includeParticipant: receiptType !== 'server-error'
+        }));
         return true;
     };
 }
@@ -138,6 +158,8 @@ export function createIncomingFailureHandler(options) {
 export 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 = getFirstNodeChild(node)?.tag;
         const baseEvent = createIncomingBaseEvent(node);
@@ -172,7 +194,12 @@ export function createIncomingNotificationHandler(options) {
                 reason: `notification.${notificationType || 'unknown'}.not_supported`
             });
         }
-        await sendSafeAck(options.logger, options.sendNode, buildNotificationAckNode(node));
+        await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+            kind: 'notification',
+            node,
+            includeParticipant: includeParticipantInAck,
+            includeType: includeTypeInAck
+        }));
         if (notificationType === 'server_sync' && serverSyncCollections.length > 0) {
             const collectionsCsv = serverSyncCollections.join(',');
             if (!options.syncAppState) {
@@ -191,6 +218,41 @@ export function createIncomingNotificationHandler(options) {
         return true;
     };
 }
+export function createIncomingRegistrationNotificationHandler(options) {
+    return async (node) => {
+        if (node.attrs.type !== WA_NOTIFICATION_TYPES.REGISTRATION) {
+            return false;
+        }
+        const parsed = 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, buildAckNode({
+            kind: 'notification',
+            node
+        }));
+        return true;
+    };
+}
 export function createIncomingGroupNotificationHandler(options) {
     return async (node) => {
         if (node.attrs.type !== WA_NOTIFICATION_TYPES.GROUP) {
@@ -210,7 +272,11 @@ export function createIncomingGroupNotificationHandler(options) {
                 reason: `notification.${WA_NOTIFICATION_TYPES.GROUP}.empty`
             });
         }
-        await sendSafeAck(options.logger, options.sendNode, buildNotificationAckNode(node));
+        await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+            kind: 'notification',
+            node,
+            includeParticipant: true
+        }));
         return true;
     };
 }