zapo-js 0.1.1 → 0.1.2

package/dist/client/coordinators/WaRetryCoordinator.js

@@ -13,12 +13,16 @@ const keygen_1 = require("../../signal/registration/keygen");
 const message_1 = require("../../transport/node/builders/message");
 const retry_1 = require("../../transport/node/builders/retry");
 const primitives_1 = require("../../util/primitives");
+const RETRY_CLEANUP_INTERVAL_MS = 30000;
 function getRetryReasonName(code) {
     if (code === undefined) {
         return undefined;
     }
-    const entry = Object.entries(constants_2.RETRY_REASON).find(([, value]) => value === code);
-    return entry ? entry[0] : 'unknown';
+    for (const reasonName in constants_2.RETRY_REASON) {
+        if (constants_2.RETRY_REASON[reasonName] === code)
+            return reasonName;
+    }
+    return 'unknown';
 }
 function getRemoteRetryReasonLogFields(reason) {
     return {
@@ -29,6 +33,7 @@ function getRemoteRetryReasonLogFields(reason) {
 }
 class WaRetryCoordinator {
     constructor(options) {
+        this.nextRetryCleanupAtMs = 0;
         this.logger = options.logger;
         this.retryStore = options.retryStore;
         this.retryTtlMs = this.retryStore.getTtlMs?.() ?? constants_2.RETRY_OUTBOUND_TTL_MS;
@@ -75,7 +80,7 @@ class WaRetryCoordinator {
             return;
         }
         try {
-            await this.retryStore.cleanupExpired(Date.now());
+            await this.maybeCleanupRetryStore(Date.now());
             const request = (0, parse_1.parseRetryReceiptRequest)(receiptNode);
             if (!request) {
                 return;
@@ -100,10 +105,7 @@ class WaRetryCoordinator {
     }
     async prepareDecryptFailureRetry(context, error) {
         const nowMs = Date.now();
-        const [, registrationInfo] = await Promise.all([
-            this.retryStore.cleanupExpired(nowMs),
-            this.signalStore.getRegistrationInfo()
-        ]);
+        const registrationInfo = await this.signalStore.getRegistrationInfo();
         if (!registrationInfo) {
             this.logger.warn('retry receipt skipped: missing local registration info', {
                 id: context.stanzaId,
@@ -198,6 +200,21 @@ class WaRetryCoordinator {
             });
             return null;
         }
+        let requesterAddress;
+        let requesterNormalizedDeviceJid;
+        try {
+            requesterAddress = (0, jid_1.parseSignalAddressFromJid)(requesterJid);
+            requesterNormalizedDeviceJid = (0, jid_1.normalizeDeviceJid)(requesterJid);
+        }
+        catch (error) {
+            this.logger.info('retry request rejected: invalid requester jid', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                message: (0, primitives_1.toError)(error).message
+            });
+            return null;
+        }
         if (request.retryCount >= constants_2.MAX_RETRY_ATTEMPTS) {
             this.logger.info('retry request rejected: retry count exceeded', {
                 id: request.stanzaId,
@@ -217,7 +234,7 @@ class WaRetryCoordinator {
             });
             return null;
         }
-        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid);
+        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!sessionReady) {
             this.logger.info('retry request rejected: missing compatible session', {
                 id: request.stanzaId,
@@ -228,7 +245,7 @@ class WaRetryCoordinator {
             });
             return null;
         }
-        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid);
+        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!authorization.authorized) {
             this.logger.info('retry request rejected', {
                 id: request.stanzaId,
@@ -242,6 +259,8 @@ class WaRetryCoordinator {
         }
         return {
             requesterJid,
+            requesterAddress,
+            requesterNormalizedDeviceJid,
             outbound
         };
     }
@@ -274,7 +293,7 @@ class WaRetryCoordinator {
     }
     async runRetryTaskSerialized(messageId, task) {
         const previous = this.retryProcessingByMessageId.get(messageId) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(async () => task());
+        const current = previous.then(task, task);
         const tracker = current.then(() => undefined, () => undefined);
         this.retryProcessingByMessageId.set(messageId, tracker);
         try {
@@ -314,18 +333,17 @@ class WaRetryCoordinator {
                 : undefined
         };
     }
-    async updateLocalSessionFromRetryRequest(request, requesterJid) {
-        await this.markRetryRequesterSenderKeyAsStale(request, requesterJid);
-        const address = (0, jid_1.parseSignalAddressFromJid)(requesterJid);
-        const currentSession = await this.signalStore.getSession(address);
+    async updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
+        await this.markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress);
+        const currentSession = await this.signalStore.getSession(requesterAddress);
         if (currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId) {
-            await this.signalStore.deleteSession(address);
+            await this.signalStore.deleteSession(requesterAddress);
         }
         if (request.keyBundle) {
-            if (!request.keyBundle.key) {
+            if (!request.keyBundle.key || !request.keyBundle.skey.signature) {
                 return false;
             }
-            await this.signalProtocol.establishOutgoingSession(address, {
+            await this.signalProtocol.establishOutgoingSession(requesterAddress, {
                 regId: request.regId,
                 identity: request.keyBundle.identity,
                 signedKey: {
@@ -340,23 +358,22 @@ class WaRetryCoordinator {
             });
             return true;
         }
-        const hasSession = await this.signalProtocol.hasSession(address);
+        const hasSession = await this.signalProtocol.hasSession(requesterAddress);
         if (hasSession) {
             return true;
         }
-        const fetched = await this.fetchMissingPreKeysSession(requesterJid, request.regId);
+        const fetched = await this.fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, request.regId);
         if (!fetched) {
             return false;
         }
-        await this.signalProtocol.establishOutgoingSession(address, fetched);
+        await this.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
         return true;
     }
-    async markRetryRequesterSenderKeyAsStale(request, requesterJid) {
+    async markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress) {
         if (!(0, jid_1.isGroupOrBroadcastJid)(request.from)) {
             return;
         }
         try {
-            const requesterAddress = (0, jid_1.parseSignalAddressFromJid)(requesterJid);
             const deleted = await this.senderKeyStore.markForgetSenderKey(request.from, [
                 requesterAddress
             ]);
@@ -374,12 +391,11 @@ class WaRetryCoordinator {
             });
         }
     }
-    async fetchMissingPreKeysSession(requesterJid, requesterRegistrationId) {
+    async fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, requesterRegistrationId) {
         try {
-            const requesterAddress = (0, jid_1.parseSignalAddressFromJid)(requesterJid);
             const results = await this.signalMissingPreKeysSync.fetchMissingPreKeys([
                 {
-                    userJid: (0, jid_1.toUserJid)(requesterJid),
+                    userJid: `${requesterAddress.user}@${requesterAddress.server}`,
                     devices: [
                         {
                             deviceId: requesterAddress.device,
@@ -396,8 +412,7 @@ class WaRetryCoordinator {
                 });
                 return null;
             }
-            const requesterDeviceJid = (0, jid_1.normalizeDeviceJid)(requesterJid);
-            const matched = first.devices.find((device) => (0, jid_1.normalizeDeviceJid)(device.deviceJid) === requesterDeviceJid);
+            const matched = first.devices.find((device) => (0, jid_1.normalizeDeviceJid)(device.deviceJid) === requesterNormalizedDeviceJid);
             if (!matched) {
                 this.logger.warn('missing prekeys fetch did not return requested device', {
                     requester: requesterJid,
@@ -415,7 +430,7 @@ class WaRetryCoordinator {
             return null;
         }
     }
-    async authorizeRetryRequest(request, outbound, requesterJid) {
+    async authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         if (outbound.state === 'ineligible') {
             return { authorized: false, reason: `state_${outbound.state}` };
         }
@@ -423,25 +438,29 @@ class WaRetryCoordinator {
         if (!isGroupOutbound && (outbound.state === 'read' || outbound.state === 'played')) {
             return { authorized: false, reason: `state_${outbound.state}` };
         }
-        const requesterAuthorized = await this.isRequesterAuthorizedDevice(requesterJid);
+        const requesterAuthorized = await this.isRequesterAuthorizedDevice(requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!requesterAuthorized) {
             return { authorized: false, reason: 'requester_device_not_authorized' };
         }
         return { authorized: true };
     }
-    async isRequesterAuthorizedDevice(requesterJid) {
+    async isRequesterAuthorizedDevice(requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         try {
-            const requesterUser = (0, jid_1.toUserJid)(requesterJid);
+            const requesterUser = `${requesterAddress.user}@${requesterAddress.server}`;
+            if (requesterNormalizedDeviceJid === (0, jid_1.normalizeDeviceJid)(requesterUser)) {
+                return true;
+            }
             const synced = await this.signalDeviceSync.syncDeviceList([requesterUser]);
             const target = synced.find((entry) => entry.jid === requesterUser);
-            const authorized = new Set();
-            authorized.add((0, jid_1.normalizeDeviceJid)(requesterUser));
-            if (target) {
-                for (let index = 0; index < target.deviceJids.length; index += 1) {
-                    authorized.add((0, jid_1.normalizeDeviceJid)(target.deviceJids[index]));
+            if (!target) {
+                return false;
+            }
+            for (let index = 0; index < target.deviceJids.length; index += 1) {
+                if ((0, jid_1.normalizeDeviceJid)(target.deviceJids[index]) === requesterNormalizedDeviceJid) {
+                    return true;
                 }
             }
-            return authorized.has((0, jid_1.normalizeDeviceJid)(requesterJid));
+            return false;
         }
         catch (error) {
             this.logger.warn('retry authorization failed while syncing requester device list', {
@@ -490,5 +509,19 @@ class WaRetryCoordinator {
             });
         }
     }
+    async maybeCleanupRetryStore(nowMs) {
+        if (nowMs < this.nextRetryCleanupAtMs) {
+            return;
+        }
+        this.nextRetryCleanupAtMs = nowMs + RETRY_CLEANUP_INTERVAL_MS;
+        try {
+            await this.retryStore.cleanupExpired(nowMs);
+        }
+        catch (error) {
+            this.logger.warn('retry store cleanup failed', {
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+    }
 }
 exports.WaRetryCoordinator = WaRetryCoordinator;

package/dist/client/dirty.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDirtyBits = parseDirtyBits;
 exports.handleDirtyBits = handleDirtyBits;
-const _crypto_1 = require("../crypto/index.js");
 const constants_1 = require("../protocol/constants");
 const jid_1 = require("../protocol/jid");
-const accountSync_1 = require("../transport/node/builders/accountSync");
+const account_sync_1 = require("../transport/node/builders/account-sync");
 const helpers_1 = require("../transport/node/helpers");
 const query_1 = require("../transport/node/query");
-const bytes_1 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 const SUPPORTED_DIRTY_TYPES = new Set(constants_1.WA_SUPPORTED_DIRTY_TYPES);
 const ACCOUNT_SYNC_PROTOCOL_SET = new Set(constants_1.WA_ACCOUNT_SYNC_PROTOCOLS);
@@ -22,19 +20,13 @@ function parseDirtyBitNode(node, logger) {
         });
         return null;
     }
-    const protocols = (0, helpers_1.getNodeChildren)(node).map((child) => child.tag);
+    const protocols = (0, helpers_1.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));
     if (selected.length > 0) {
@@ -43,9 +35,15 @@ function resolveAccountSyncProtocols(protocols) {
     return constants_1.WA_ACCOUNT_SYNC_PROTOCOLS;
 }
 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;
 }
 async function handleDirtyBits(runtime, dirtyBits) {
     const meJid = runtime.getCurrentCredentials()?.meJid ?? null;
@@ -53,22 +51,33 @@ 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);
+    }
     runtime.logger.info('handling dirty bits from info bulletin', {
         supported: supported.map((entry) => entry.type).join(','),
         unsupported: unsupported.map((entry) => entry.type).join(',')
     });
-    const handledSupported = (await Promise.allSettled(supported.map(async (dirtyBit) => handleDirtyBit(runtime, dirtyBit)))).flatMap((result, index) => {
+    const clearableDirtyBits = [...unsupported];
+    const settledSupported = await Promise.allSettled(supported.map(async (dirtyBit) => handleDirtyBit(runtime, dirtyBit)));
+    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: (0, primitives_1.toError)(result.reason).message
         });
-        return [];
-    });
-    await clearDirtyBits(runtime, unsupported.concat(handledSupported));
+    }
+    await clearDirtyBits(runtime, clearableDirtyBits);
 }
 async function handleDirtyBit(runtime, dirtyBit) {
     switch (dirtyBit.type) {
@@ -153,7 +162,7 @@ async function syncAccountDevicesDirtyBit(runtime) {
     }
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.devices',
-        node: (0, accountSync_1.buildAccountDevicesSyncIq)(userJids, await generateUsyncSid()),
+        node: (0, account_sync_1.buildAccountDevicesSyncIq)(userJids, await runtime.generateUsyncSid()),
         logMessage: 'account_sync devices synchronized',
         contextData: { meJid, targets: userJids.join(',') }
     });
@@ -165,7 +174,7 @@ async function syncAccountPictureDirtyBit(runtime) {
         return;
     }
     const targetJid = (0, jid_1.toUserJid)(meJid);
-    const response = await runtime.queryWithContext('account_sync.picture', (0, accountSync_1.buildAccountPictureSyncIq)(targetJid), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, { meJid, target: targetJid });
+    const response = await runtime.queryWithContext('account_sync.picture', (0, account_sync_1.buildAccountPictureSyncIq)(targetJid), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, { meJid, target: targetJid });
     if (response.tag !== 'iq') {
         throw new Error(`account_sync.picture returned non-iq node (${response.tag})`);
     }
@@ -191,14 +200,14 @@ async function syncAccountPictureDirtyBit(runtime) {
 async function syncAccountPrivacyDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.privacy',
-        node: (0, accountSync_1.buildAccountPrivacySyncIq)(),
+        node: (0, account_sync_1.buildAccountPrivacySyncIq)(),
         logMessage: 'account_sync privacy synchronized'
     });
 }
 async function syncAccountBlocklistDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.blocklist',
-        node: (0, accountSync_1.buildAccountBlocklistSyncIq)(),
+        node: (0, account_sync_1.buildAccountBlocklistSyncIq)(),
         logMessage: 'account_sync blocklist synchronized'
     });
 }
@@ -209,16 +218,13 @@ async function syncGroupsDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'dirty.groups',
         assertContext: 'groups',
-        node: (0, accountSync_1.buildGroupsDirtySyncIq)(),
+        node: (0, account_sync_1.buildGroupsDirtySyncIq)(),
         logMessage: 'groups dirty sync completed'
     });
 }
 async function syncNewsletterMetadataDirtyBit(runtime) {
     runtime.logger.info('newsletter_metadata dirty bit received (GraphQL/MEX sync intentionally disabled)');
-    await runtime.queryWithContext('dirty.newsletter_metadata', (0, accountSync_1.buildNewsletterMetadataSyncIq)(), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS);
-}
-async function generateUsyncSid() {
-    return (0, bytes_1.bytesToHex)(await (0, _crypto_1.randomBytesAsync)(8));
+    await runtime.queryWithContext('dirty.newsletter_metadata', (0, account_sync_1.buildNewsletterMetadataSyncIq)(), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS);
 }
 function resolveAccountSyncDeviceTargets(credentials) {
     if (!credentials?.meJid) {
@@ -238,7 +244,7 @@ async function runSyncQuery(runtime, args) {
 }
 async function clearDirtyBits(runtime, dirtyBits) {
     try {
-        await runtime.queryWithContext('dirty.clear', (0, accountSync_1.buildClearDirtyBitsIq)(dirtyBits), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, {
+        await runtime.queryWithContext('dirty.clear', (0, account_sync_1.buildClearDirtyBitsIq)(dirtyBits), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: dirtyBits.length
         });
         runtime.logger.info('dirty bits cleared', {

package/dist/client/events/chat.js

@@ -78,8 +78,7 @@ 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;
     }
@@ -204,10 +203,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/client/events/group.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseParticipants = parseParticipants;
 exports.parseGroupNotificationEvents = parseGroupNotificationEvents;
 const constants_1 = require("../../protocol/constants");
 const nodes_1 = require("../../protocol/nodes");
 const helpers_1 = require("../../transport/node/helpers");
-const parse_1 = require("../../transport/stream/parse");
 const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
 function readNodeTextContent(node) {
     if (!node) {
         return undefined;
@@ -19,30 +20,42 @@ function readNodeTextContent(node) {
     return undefined;
 }
 function parseParticipants(node) {
-    return (0, helpers_1.getNodeChildrenByTag)(node, nodes_1.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: (0, parse_1.parseOptionalInt)(participantNode.attrs.expiration)
-    }));
+    const participants = [];
+    for (const participantNode of (0, helpers_1.getNodeChildrenByTag)(node, nodes_1.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: (0, primitives_1.parseOptionalInt)(participantNode.attrs.expiration)
+        });
+    }
+    return participants;
 }
 function parseLinkedGroups(node) {
-    return (0, helpers_1.getNodeChildrenByTag)(node, nodes_1.WA_NODE_TAGS.GROUP).map((groupNode) => ({
-        jid: groupNode.attrs.jid,
-        subject: groupNode.attrs.subject,
-        subjectTimestampSeconds: (0, parse_1.parseOptionalInt)(groupNode.attrs.s_t),
-        hiddenSubgroup: (0, helpers_1.findNodeChild)(groupNode, 'hidden_group') !== undefined
-    }));
+    const groups = [];
+    for (const groupNode of (0, helpers_1.getNodeChildrenByTag)(node, nodes_1.WA_NODE_TAGS.GROUP)) {
+        groups.push({
+            jid: groupNode.attrs.jid,
+            subject: groupNode.attrs.subject,
+            subjectTimestampSeconds: (0, primitives_1.parseOptionalInt)(groupNode.attrs.s_t),
+            hiddenSubgroup: (0, helpers_1.findNodeChild)(groupNode, 'hidden_group') !== undefined
+        });
+    }
+    return groups;
 }
 function parseMembershipRequests(node) {
-    return (0, helpers_1.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 (0, helpers_1.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 = (0, helpers_1.findNodeChild)(node, nodes_1.WA_NODE_TAGS.SUBJECT);
@@ -57,20 +70,26 @@ function parseSubgroupSuggestion(node) {
         ownerJid: node.attrs.creator,
         subject: readNodeTextContent(subjectNode),
         description: readNodeTextContent(descriptionBodyNode),
-        timestampSeconds: (0, parse_1.parseOptionalInt)(node.attrs.creation),
+        timestampSeconds: (0, primitives_1.parseOptionalInt)(node.attrs.creation),
         isExistingGroup: readNodeTextContent(isExistingGroupNode) === undefined
             ? undefined
             : readNodeTextContent(isExistingGroupNode) === 'true',
         participantCount: participantCountNode
-            ? (0, parse_1.parseOptionalInt)(readNodeTextContent(participantCountNode))
+            ? (0, primitives_1.parseOptionalInt)(readNodeTextContent(participantCountNode))
             : undefined,
         reason: node.attrs.reason
     };
 }
 function parseSubgroupSuggestions(node) {
-    return (0, helpers_1.getNodeChildrenByTag)(node, 'sub_group_suggestion')
-        .map(parseSubgroupSuggestion)
-        .filter((suggestion) => suggestion !== null);
+    const suggestions = [];
+    for (const suggestionNode of (0, helpers_1.getNodeChildrenByTag)(node, 'sub_group_suggestion')) {
+        const suggestion = parseSubgroupSuggestion(suggestionNode);
+        if (!suggestion) {
+            continue;
+        }
+        suggestions.push(suggestion);
+    }
+    return suggestions;
 }
 function createBaseGroupEvent(notificationNode, actionNode) {
     return {
@@ -81,7 +100,7 @@ function createBaseGroupEvent(notificationNode, actionNode) {
         stanzaType: notificationNode.attrs.type,
         groupJid: notificationNode.attrs.from,
         authorJid: notificationNode.attrs.participant,
-        timestampSeconds: (0, parse_1.parseOptionalInt)(notificationNode.attrs.t)
+        timestampSeconds: (0, primitives_1.parseOptionalInt)(notificationNode.attrs.t)
     };
 }
 function createUnhandledStanzaEvent(notificationNode, reason) {
@@ -121,7 +140,7 @@ function parseCreateGroupAction(notificationNode, actionNode) {
             creatorPhoneJid: groupNode.attrs.creator_pn,
             creatorUsername: groupNode.attrs.creator_username,
             creatorCountryCode: groupNode.attrs.creator_country_code,
-            creationSeconds: (0, parse_1.parseOptionalInt)(groupNode.attrs.creation),
+            creationSeconds: (0, primitives_1.parseOptionalInt)(groupNode.attrs.creation),
             announceEnabled: (0, helpers_1.findNodeChild)(groupNode, nodes_1.WA_NODE_TAGS.ANNOUNCEMENT) !== undefined,
             restrictEnabled: (0, helpers_1.findNodeChild)(groupNode, nodes_1.WA_NODE_TAGS.LOCKED) !== undefined,
             noFrequentlyForwardedEnabled: (0, helpers_1.findNodeChild)(groupNode, constants_1.WA_GROUP_NOTIFICATION_TAGS.NO_FREQUENTLY_FORWARDED) !==
@@ -135,12 +154,11 @@ function parseCreateGroupAction(notificationNode, actionNode) {
             hasCapi: (0, helpers_1.findNodeChild)(groupNode, 'capi') !== undefined,
             limitSharingEnabled: (0, helpers_1.findNodeChild)(groupNode, constants_1.WA_GROUP_NOTIFICATION_TAGS.LIMIT_SHARING_ENABLED) !==
                 undefined,
-            size: (0, parse_1.parseOptionalInt)(groupNode.attrs.size),
-            ephemeralDuration: (0, parse_1.parseOptionalInt)((0, helpers_1.findNodeChild)(groupNode, nodes_1.WA_NODE_TAGS.EPHEMERAL)?.attrs.expiration),
+            size: (0, primitives_1.parseOptionalInt)(groupNode.attrs.size),
+            ephemeralDuration: (0, primitives_1.parseOptionalInt)((0, helpers_1.findNodeChild)(groupNode, nodes_1.WA_NODE_TAGS.EPHEMERAL)?.attrs.expiration),
             disappearingTrigger: (0, helpers_1.findNodeChild)(groupNode, nodes_1.WA_NODE_TAGS.EPHEMERAL)?.attrs.trigger,
             membershipApprovalEnabled: groupJoinNode?.attrs.state === 'on',
-            allowNonAdminSubGroupCreation: (0, helpers_1.findNodeChild)(groupNode, constants_1.WA_GROUP_NOTIFICATION_TAGS.ALLOW_NON_ADMIN_SUB_GROUP_CREATION) !==
-                undefined,
+            allowNonAdminSubGroupCreation: (0, helpers_1.findNodeChild)(groupNode, constants_1.WA_GROUP_NOTIFICATION_TAGS.ALLOW_NON_ADMIN_SUB_GROUP_CREATION) !== undefined,
             linkedParentGroupJid: (0, helpers_1.findNodeChild)(groupNode, 'linked_parent')?.attrs.jid ??
                 (0, helpers_1.findNodeChild)(groupNode, 'parent')?.attrs.jid
         }
@@ -212,7 +230,7 @@ function parseGroupActionNode(notificationNode, actionNode) {
                 details: {
                     subjectOwnerPhoneJid: actionNode.attrs.s_o_pn,
                     subjectOwnerUsername: actionNode.attrs.s_o_username,
-                    subjectTimestampSeconds: (0, parse_1.parseOptionalInt)(actionNode.attrs.s_t)
+                    subjectTimestampSeconds: (0, primitives_1.parseOptionalInt)(actionNode.attrs.s_t)
                 }
             };
         case constants_1.WA_GROUP_NOTIFICATION_TAGS.DESCRIPTION: {
@@ -227,7 +245,12 @@ function parseGroupActionNode(notificationNode, actionNode) {
             };
         }
         case constants_1.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 constants_1.WA_GROUP_NOTIFICATION_TAGS.UNLOCKED:
             return { ...baseEvent, action: 'restrict', enabled: false };
         case constants_1.WA_GROUP_NOTIFICATION_TAGS.ANNOUNCEMENT:
@@ -244,7 +267,7 @@ function parseGroupActionNode(notificationNode, actionNode) {
             return {
                 ...baseEvent,
                 action: 'ephemeral',
-                expirationSeconds: (0, parse_1.parseOptionalInt)(actionNode.attrs.expiration),
+                expirationSeconds: (0, primitives_1.parseOptionalInt)(actionNode.attrs.expiration),
                 mode: actionNode.attrs.trigger
             };
         case constants_1.WA_GROUP_NOTIFICATION_TAGS.NOT_EPHEMERAL:
@@ -263,7 +286,7 @@ function parseGroupActionNode(notificationNode, actionNode) {
             return {
                 ...baseEvent,
                 action: 'growth_locked',
-                expirationSeconds: (0, parse_1.parseOptionalInt)(actionNode.attrs.expiration),
+                expirationSeconds: (0, primitives_1.parseOptionalInt)(actionNode.attrs.expiration),
                 mode: actionNode.attrs.type
             };
         case constants_1.WA_GROUP_NOTIFICATION_TAGS.GROWTH_UNLOCKED: