zapo-js 0.1.1 → 0.2.0

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

@@ -0,0 +1,162 @@
+import { CsTokenGenerator } from '../tokens/cs-token.js';
+import { isTokenExpired, shouldSendNewToken, clampDuration } from '../tokens/tc-token.js';
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { WA_PRIVACY_TOKEN_TYPES, WA_TC_TOKEN_DEFAULTS } from '../../protocol/privacy-token.js';
+import { buildPrivacyTokenIqNode, buildTcTokenMessageNode, buildCsTokenMessageNode } from '../../transport/node/builders/privacy-token.js';
+import { toError } from '../../util/primitives.js';
+const NCT_SALT_SENTINEL_JID = '__nct_salt__';
+export class WaTrustedContactTokenCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.store = options.store;
+        this.runtime = options.runtime;
+        const maxDurationS = options.maxDurationS ?? WA_TC_TOKEN_DEFAULTS.MAX_DURATION_S;
+        this.config = {
+            durationS: clampDuration(options.durationS ?? WA_TC_TOKEN_DEFAULTS.DURATION_S, maxDurationS),
+            numBuckets: options.numBuckets ?? WA_TC_TOKEN_DEFAULTS.NUM_BUCKETS,
+            senderDurationS: clampDuration(options.senderDurationS ?? WA_TC_TOKEN_DEFAULTS.SENDER_DURATION_S, maxDurationS),
+            senderNumBuckets: options.senderNumBuckets ?? WA_TC_TOKEN_DEFAULTS.SENDER_NUM_BUCKETS,
+            maxDurationS
+        };
+        this.csTokenGenerator = new CsTokenGenerator();
+        this.senderTokenDedup = new PromiseDedup();
+        this.cachedNctSalt = null;
+        this.nctSaltHydrated = false;
+    }
+    async resolveTokenForMessage(recipientJid) {
+        const record = await this.store.getByJid(recipientJid);
+        const nowS = Math.floor(Date.now() / 1000);
+        if (record?.tcToken &&
+            record.tcTokenTimestamp !== undefined &&
+            !isTokenExpired(record.tcTokenTimestamp, nowS, this.config.durationS, this.config.numBuckets)) {
+            return buildTcTokenMessageNode(record.tcToken);
+        }
+        const nctSalt = await this.getNctSalt();
+        if (!nctSalt) {
+            return null;
+        }
+        const meLid = this.runtime.getCurrentMeLid();
+        if (!meLid) {
+            return null;
+        }
+        const hash = await this.csTokenGenerator.generate(nctSalt, meLid);
+        return buildCsTokenMessageNode(hash);
+    }
+    async handleIncomingToken(fromJid, tokens) {
+        const nowMs = Date.now();
+        for (let i = 0; i < tokens.length; i += 1) {
+            const token = tokens[i];
+            if (token.type !== WA_PRIVACY_TOKEN_TYPES.TRUSTED_CONTACT) {
+                this.logger.warn('ignoring unknown privacy token type', { type: token.type });
+                continue;
+            }
+            await this.store.upsert({
+                jid: fromJid,
+                tcToken: token.tokenBytes,
+                tcTokenTimestamp: token.timestampS,
+                updatedAtMs: nowMs
+            });
+            this.runtime.emitEvent('privacy_token_update', {
+                jid: fromJid,
+                timestampS: token.timestampS,
+                type: token.type,
+                source: 'notification'
+            });
+        }
+    }
+    async maybeIssueSenderToken(recipientJid) {
+        return this.senderTokenDedup.run(recipientJid, async () => {
+            const nowS = Math.floor(Date.now() / 1000);
+            const record = await this.store.getByJid(recipientJid);
+            const senderTimestampS = record?.tcTokenSenderTimestamp;
+            if (senderTimestampS !== undefined && senderTimestampS > 0) {
+                if (!shouldSendNewToken(senderTimestampS, nowS, this.config.senderDurationS)) {
+                    return;
+                }
+            }
+            await this.issuePrivacyToken(recipientJid, nowS);
+            await this.store.upsert({
+                jid: recipientJid,
+                tcTokenSenderTimestamp: nowS,
+                updatedAtMs: Date.now()
+            });
+        });
+    }
+    async reissueOnIdentityChange(jid) {
+        const record = await this.store.getByJid(jid);
+        if (!record?.tcTokenSenderTimestamp) {
+            return;
+        }
+        const nowS = Math.floor(Date.now() / 1000);
+        if (isTokenExpired(record.tcTokenSenderTimestamp, nowS, this.config.senderDurationS, this.config.senderNumBuckets)) {
+            return;
+        }
+        try {
+            await this.issuePrivacyToken(jid, record.tcTokenSenderTimestamp);
+        }
+        catch (error) {
+            this.logger.warn('send-tc-token-device-identity-change-failed', {
+                jid,
+                message: toError(error).message
+            });
+        }
+    }
+    async hydrateFromHistorySync(conversations) {
+        const nowMs = Date.now();
+        const records = [];
+        for (let i = 0; i < conversations.length; i += 1) {
+            const conv = conversations[i];
+            if (!conv.tcToken && !conv.tcTokenTimestamp && !conv.tcTokenSenderTimestamp) {
+                continue;
+            }
+            records[records.length] = {
+                jid: conv.jid,
+                tcToken: conv.tcToken ?? undefined,
+                tcTokenTimestamp: conv.tcTokenTimestamp ?? undefined,
+                tcTokenSenderTimestamp: conv.tcTokenSenderTimestamp ?? undefined,
+                updatedAtMs: nowMs
+            };
+        }
+        if (records.length > 0) {
+            await this.store.upsertBatch(records);
+        }
+    }
+    async handleNctSaltSync(salt) {
+        if (salt) {
+            await this.store.upsert({
+                jid: NCT_SALT_SENTINEL_JID,
+                nctSalt: salt,
+                updatedAtMs: Date.now()
+            });
+            this.cachedNctSalt = salt;
+        }
+        else {
+            await this.store.deleteByJid(NCT_SALT_SENTINEL_JID);
+            this.cachedNctSalt = null;
+        }
+        this.nctSaltHydrated = true;
+        this.csTokenGenerator.invalidate();
+    }
+    async hydrateNctSaltFromHistorySync(salt) {
+        await this.store.upsert({
+            jid: NCT_SALT_SENTINEL_JID,
+            nctSalt: salt,
+            updatedAtMs: Date.now()
+        });
+        this.cachedNctSalt = salt;
+        this.nctSaltHydrated = true;
+    }
+    async getNctSalt() {
+        if (this.nctSaltHydrated) {
+            return this.cachedNctSalt;
+        }
+        const record = await this.store.getByJid(NCT_SALT_SENTINEL_JID);
+        this.cachedNctSalt = record?.nctSalt ?? null;
+        this.nctSaltHydrated = true;
+        return this.cachedNctSalt;
+    }
+    async issuePrivacyToken(jid, timestampS) {
+        const node = buildPrivacyTokenIqNode({ jid, timestampS });
+        await this.runtime.queryWithContext('issue-privacy-token', node);
+    }
+}

package/dist/esm/client/dirty.js

@@ -1,10 +1,8 @@
-import { randomBytesAsync } from '../crypto/index.js';
 import { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_IQ_TYPES, WA_SUPPORTED_DIRTY_TYPES } from '../protocol/constants.js';
 import { toUserJid } from '../protocol/jid.js';
-import { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../transport/node/builders/accountSync.js';
-import { getNodeChildren } from '../transport/node/helpers.js';
+import { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../transport/node/builders/account-sync.js';
+import { getNodeChildrenTags } from '../transport/node/helpers.js';
 import { assertIqResult, parseIqError } from '../transport/node/query.js';
-import { bytesToHex } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 const SUPPORTED_DIRTY_TYPES = new Set(WA_SUPPORTED_DIRTY_TYPES);
 const ACCOUNT_SYNC_PROTOCOL_SET = new Set(WA_ACCOUNT_SYNC_PROTOCOLS);
@@ -18,30 +16,36 @@ function parseDirtyBitNode(node, logger) {
         });
         return null;
     }
-    const protocols = getNodeChildren(node).map((child) => child.tag);
+    const protocols = getNodeChildrenTags(node);
     return {
         type,
         timestamp,
         protocols
     };
 }
-function splitDirtyBitsBySupport(dirtyBits) {
-    return {
-        supported: dirtyBits.filter((dirtyBit) => SUPPORTED_DIRTY_TYPES.has(dirtyBit.type)),
-        unsupported: dirtyBits.filter((dirtyBit) => !SUPPORTED_DIRTY_TYPES.has(dirtyBit.type))
-    };
-}
 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;
     }
     return WA_ACCOUNT_SYNC_PROTOCOLS;
 }
 export function parseDirtyBits(nodes, logger) {
-    return nodes
-        .map((node) => parseDirtyBitNode(node, logger))
-        .filter((dirtyBit) => dirtyBit !== null);
+    const parsed = [];
+    for (const node of nodes) {
+        const dirtyBit = parseDirtyBitNode(node, logger);
+        if (!dirtyBit) {
+            continue;
+        }
+        parsed.push(dirtyBit);
+    }
+    return parsed;
 }
 export async function handleDirtyBits(runtime, dirtyBits) {
     const meJid = runtime.getCurrentCredentials()?.meJid ?? null;
@@ -49,22 +53,45 @@ export async function handleDirtyBits(runtime, dirtyBits) {
         runtime.logger.trace('dirty bits skipped: session is not registered');
         return;
     }
-    const { supported, unsupported } = splitDirtyBitsBySupport(dirtyBits);
+    const supported = [];
+    const unsupported = [];
+    for (const dirtyBit of dirtyBits) {
+        if (SUPPORTED_DIRTY_TYPES.has(dirtyBit.type)) {
+            supported.push(dirtyBit);
+            continue;
+        }
+        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 handledSupported = (await Promise.allSettled(supported.map(async (dirtyBit) => handleDirtyBit(runtime, dirtyBit)))).flatMap((result, index) => {
+    const clearableDirtyBits = [...unsupported];
+    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') {
-            return [supported[index]];
+            clearableDirtyBits.push(supported[index]);
+            continue;
         }
         runtime.logger.warn('failed handling dirty bit', {
             type: supported[index].type,
             message: toError(result.reason).message
         });
-        return [];
-    });
-    await clearDirtyBits(runtime, unsupported.concat(handledSupported));
+    }
+    await clearDirtyBits(runtime, clearableDirtyBits);
 }
 async function handleDirtyBit(runtime, dirtyBit) {
     switch (dirtyBit.type) {
@@ -92,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(',')}`);
     }
@@ -123,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', {
@@ -149,7 +181,7 @@ async function syncAccountDevicesDirtyBit(runtime) {
     }
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.devices',
-        node: buildAccountDevicesSyncIq(userJids, await generateUsyncSid()),
+        node: buildAccountDevicesSyncIq(userJids, await runtime.generateUsyncSid()),
         logMessage: 'account_sync devices synchronized',
         contextData: { meJid, targets: userJids.join(',') }
     });
@@ -198,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',
@@ -213,9 +242,6 @@ async function syncNewsletterMetadataDirtyBit(runtime) {
     runtime.logger.info('newsletter_metadata dirty bit received (GraphQL/MEX sync intentionally disabled)');
     await runtime.queryWithContext('dirty.newsletter_metadata', buildNewsletterMetadataSyncIq(), WA_DEFAULTS.IQ_TIMEOUT_MS);
 }
-async function generateUsyncSid() {
-    return bytesToHex(await randomBytesAsync(8));
-}
 function resolveAccountSyncDeviceTargets(credentials) {
     if (!credentials?.meJid) {
         return [];

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

@@ -75,8 +75,7 @@ export function parseChatEventFromAppStateMutation(mutation) {
             ...pickOptionalPrimitive('deviceAgentId', value.chatAssignment.deviceAgentID, 'string')
         };
     }
-    const fallbackAction = normalizeIndexAction(parsedIndex?.action) ??
-        normalizeValueActionKey(syncActionValueKey);
+    const fallbackAction = normalizeIndexAction(parsedIndex?.action) ?? normalizeValueActionKey(syncActionValueKey);
     if (!fallbackAction) {
         return null;
     }
@@ -201,10 +200,12 @@ function extractChatJid(parts) {
     return undefined;
 }
 function findPresentSyncActionValueKey(value) {
-    for (const [key, keyValue] of Object.entries(value)) {
+    const valueRecord = value;
+    for (const key in valueRecord) {
         if (key === 'timestamp') {
             continue;
         }
+        const keyValue = valueRecord[key];
         if (keyValue === null || keyValue === undefined) {
             continue;
         }

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,8 +1,9 @@
+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';
-import { parseOptionalInt } from '../../transport/stream/parse.js';
 import { TEXT_DECODER } from '../../util/bytes.js';
+import { parseOptionalInt } from '../../util/primitives.js';
 function readNodeTextContent(node) {
     if (!node) {
         return undefined;
@@ -15,31 +16,43 @@ function readNodeTextContent(node) {
     }
     return undefined;
 }
-function parseParticipants(node) {
-    return getNodeChildrenByTag(node, WA_NODE_TAGS.PARTICIPANT).map((participantNode) => ({
-        jid: participantNode.attrs.jid,
-        role: participantNode.attrs.type,
-        lidJid: participantNode.attrs.lid,
-        phoneJid: participantNode.attrs.phone_number,
-        displayName: participantNode.attrs.display_name,
-        username: participantNode.attrs.username,
-        expirationSeconds: parseOptionalInt(participantNode.attrs.expiration)
-    }));
+export function parseParticipants(node) {
+    const participants = [];
+    for (const participantNode of getNodeChildrenByTag(node, WA_NODE_TAGS.PARTICIPANT)) {
+        participants.push({
+            jid: participantNode.attrs.jid,
+            role: participantNode.attrs.type,
+            lidJid: participantNode.attrs.lid,
+            phoneJid: participantNode.attrs.phone_number,
+            displayName: participantNode.attrs.display_name,
+            username: participantNode.attrs.username,
+            expirationSeconds: parseOptionalInt(participantNode.attrs.expiration)
+        });
+    }
+    return participants;
 }
 function parseLinkedGroups(node) {
-    return getNodeChildrenByTag(node, WA_NODE_TAGS.GROUP).map((groupNode) => ({
-        jid: groupNode.attrs.jid,
-        subject: groupNode.attrs.subject,
-        subjectTimestampSeconds: parseOptionalInt(groupNode.attrs.s_t),
-        hiddenSubgroup: findNodeChild(groupNode, 'hidden_group') !== undefined
-    }));
+    const groups = [];
+    for (const groupNode of getNodeChildrenByTag(node, WA_NODE_TAGS.GROUP)) {
+        groups.push({
+            jid: groupNode.attrs.jid,
+            subject: groupNode.attrs.subject,
+            subjectTimestampSeconds: parseOptionalInt(groupNode.attrs.s_t),
+            hiddenSubgroup: findNodeChild(groupNode, 'hidden_group') !== undefined
+        });
+    }
+    return groups;
 }
 function parseMembershipRequests(node) {
-    return getNodeChildrenByTag(node, 'requested_user').map((requestNode) => ({
-        jid: requestNode.attrs.jid,
-        username: requestNode.attrs.username,
-        phoneJid: requestNode.attrs.phone_number
-    }));
+    const requests = [];
+    for (const requestNode of getNodeChildrenByTag(node, 'requested_user')) {
+        requests.push({
+            jid: requestNode.attrs.jid,
+            username: requestNode.attrs.username,
+            phoneJid: requestNode.attrs.phone_number
+        });
+    }
+    return requests;
 }
 function parseSubgroupSuggestion(node) {
     const subjectNode = findNodeChild(node, WA_NODE_TAGS.SUBJECT);
@@ -65,9 +78,15 @@ function parseSubgroupSuggestion(node) {
     };
 }
 function parseSubgroupSuggestions(node) {
-    return getNodeChildrenByTag(node, 'sub_group_suggestion')
-        .map(parseSubgroupSuggestion)
-        .filter((suggestion) => suggestion !== null);
+    const suggestions = [];
+    for (const suggestionNode of getNodeChildrenByTag(node, 'sub_group_suggestion')) {
+        const suggestion = parseSubgroupSuggestion(suggestionNode);
+        if (!suggestion) {
+            continue;
+        }
+        suggestions.push(suggestion);
+    }
+    return suggestions;
 }
 function createBaseGroupEvent(notificationNode, actionNode) {
     return {
@@ -81,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) {
@@ -136,8 +146,7 @@ function parseCreateGroupAction(notificationNode, actionNode) {
             ephemeralDuration: parseOptionalInt(findNodeChild(groupNode, WA_NODE_TAGS.EPHEMERAL)?.attrs.expiration),
             disappearingTrigger: findNodeChild(groupNode, WA_NODE_TAGS.EPHEMERAL)?.attrs.trigger,
             membershipApprovalEnabled: groupJoinNode?.attrs.state === 'on',
-            allowNonAdminSubGroupCreation: findNodeChild(groupNode, WA_GROUP_NOTIFICATION_TAGS.ALLOW_NON_ADMIN_SUB_GROUP_CREATION) !==
-                undefined,
+            allowNonAdminSubGroupCreation: findNodeChild(groupNode, WA_GROUP_NOTIFICATION_TAGS.ALLOW_NON_ADMIN_SUB_GROUP_CREATION) !== undefined,
             linkedParentGroupJid: findNodeChild(groupNode, 'linked_parent')?.attrs.jid ??
                 findNodeChild(groupNode, 'parent')?.attrs.jid
         }
@@ -224,7 +233,12 @@ function parseGroupActionNode(notificationNode, actionNode) {
             };
         }
         case WA_GROUP_NOTIFICATION_TAGS.LOCKED:
-            return { ...baseEvent, action: 'restrict', enabled: true, mode: actionNode.attrs.threshold };
+            return {
+                ...baseEvent,
+                action: 'restrict',
+                enabled: true,
+                mode: actionNode.attrs.threshold
+            };
         case WA_GROUP_NOTIFICATION_TAGS.UNLOCKED:
             return { ...baseEvent, action: 'restrict', enabled: false };
         case WA_GROUP_NOTIFICATION_TAGS.ANNOUNCEMENT:
@@ -391,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,36 @@
+import { WA_PRIVACY_TOKEN_TAGS } from '../../protocol/privacy-token.js';
+import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { toBytesView } from '../../util/bytes.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: toBytesView(content),
+            timestampS: asNumber(Number(rawTimestamp), 'privacy_token.t')
+        };
+    }
+    return result;
+}