zapo-js 0.1.0 → 0.1.2

package/dist/retry/tracker.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOutboundRetryTracker = createOutboundRetryTracker;
+const constants_1 = require("./constants");
+const outbound_1 = require("./outbound");
+const primitives_1 = require("../util/primitives");
+function createOutboundRetryTracker(options) {
+    const { retryStore, logger } = options;
+    const retryTtlMs = retryStore.getTtlMs?.() ?? constants_1.RETRY_OUTBOUND_TTL_MS;
+    const safeUpsertRetryOutboundRecord = async (record) => {
+        try {
+            await retryStore.upsertOutboundMessage(record);
+        }
+        catch (error) {
+            logger.warn('failed to persist retry outbound message record', {
+                messageId: record.messageId,
+                to: record.toJid,
+                mode: record.replayMode,
+                message: (0, primitives_1.toError)(error).message
+            });
+            return false;
+        }
+        return true;
+    };
+    return {
+        track: async (hint, publish) => {
+            const nowMs = Date.now();
+            const expiresAtMs = nowMs + retryTtlMs;
+            const hintedMessageId = hint.messageIdHint?.trim();
+            const replayMode = hint.replayPayload.mode;
+            const resolvedToJid = hint.toJid ?? (replayMode === 'opaque_node' ? '' : hint.replayPayload.to);
+            const replayPayload = (0, outbound_1.encodeRetryReplayPayload)(hint.replayPayload);
+            let hintedPersisted = false;
+            const createRetryOutboundRecord = (messageId, createdAtMs, updatedAtMs, expiresAtMs) => ({
+                messageId,
+                toJid: resolvedToJid,
+                participantJid: hint.participantJid,
+                recipientJid: hint.recipientJid,
+                messageType: hint.type,
+                replayMode,
+                replayPayload,
+                state: 'pending',
+                createdAtMs,
+                updatedAtMs,
+                expiresAtMs
+            });
+            if (hintedMessageId) {
+                hintedPersisted = await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(hintedMessageId, nowMs, nowMs, expiresAtMs));
+            }
+            const result = await publish();
+            if (hintedPersisted && hintedMessageId && result.id === hintedMessageId) {
+                return result;
+            }
+            const persistedNowMs = Date.now();
+            await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(result.id, hintedMessageId ? nowMs : persistedNowMs, persistedNowMs, persistedNowMs + retryTtlMs));
+            return result;
+        }
+    };
+}

package/dist/signal/api/SignalDeviceSyncApi.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalDeviceSyncApi = void 0;
-const node_crypto_1 = require("node:crypto");
 const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
+const usync_1 = require("../../transport/node/builders/usync");
 const helpers_1 = require("../../transport/node/helpers");
 const query_1 = require("../../transport/node/query");
+const usync_2 = require("../../transport/node/usync");
 class SignalDeviceSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -14,6 +15,7 @@ class SignalDeviceSyncApi {
         this.defaultTimeoutMs =
             options.defaultTimeoutMs ?? constants_1.WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
+        this.generateSid = options.generateSid ?? (0, usync_2.createUsyncSidGenerator)();
     }
     async syncDeviceList(userJids, timeoutMs = this.defaultTimeoutMs) {
         const normalizedUsers = this.normalizeUsers(userJids);
@@ -26,12 +28,18 @@ class SignalDeviceSyncApi {
             ? await this.collectUsersToQuery(normalizedUsers, nowMs, cachedByUser, this.deviceListStore)
             : normalizedUsers;
         if (usersToQuery.length === 0) {
-            return normalizedUsers.map((jid) => ({
-                jid,
-                deviceJids: cachedByUser.get(jid) ?? []
-            }));
+            const fromCache = new Array(normalizedUsers.length);
+            for (let index = 0; index < normalizedUsers.length; index += 1) {
+                const jid = normalizedUsers[index];
+                fromCache[index] = {
+                    jid,
+                    deviceJids: cachedByUser.get(jid) ?? []
+                };
+            }
+            return fromCache;
         }
-        const request = this.makeDeviceSyncRequest(usersToQuery);
+        const sid = await this.generateSid();
+        const request = this.makeDeviceSyncRequest(usersToQuery, sid);
         this.logger.debug('signal device sync request', {
             users: usersToQuery.length,
             timeoutMs
@@ -40,23 +48,82 @@ class SignalDeviceSyncApi {
         const parsed = this.parseDeviceSyncResponse(response, usersToQuery);
         if (this.deviceListStore) {
             const updatedAtMs = Date.now();
-            await this.deviceListStore.upsertUserDevicesBatch(parsed.map((entry) => ({
-                userJid: entry.jid,
-                deviceJids: entry.deviceJids,
-                updatedAtMs
-            })));
-        }
-        const parsedByUser = new Map(parsed.map((entry) => [entry.jid, entry.deviceJids]));
-        const merged = normalizedUsers.map((jid) => ({
-            jid,
-            deviceJids: parsedByUser.get(jid) ?? cachedByUser.get(jid) ?? []
-        }));
+            const batch = new Array(parsed.length);
+            for (let index = 0; index < parsed.length; index += 1) {
+                const entry = parsed[index];
+                batch[index] = {
+                    userJid: entry.jid,
+                    deviceJids: entry.deviceJids,
+                    updatedAtMs
+                };
+            }
+            await this.deviceListStore.upsertUserDevicesBatch(batch);
+        }
+        const parsedByUser = new Map();
+        for (let index = 0; index < parsed.length; index += 1) {
+            const entry = parsed[index];
+            parsedByUser.set(entry.jid, entry.deviceJids);
+        }
+        const merged = new Array(normalizedUsers.length);
+        let totalDevices = 0;
+        for (let index = 0; index < normalizedUsers.length; index += 1) {
+            const jid = normalizedUsers[index];
+            const deviceJids = parsedByUser.get(jid) ?? cachedByUser.get(jid) ?? [];
+            totalDevices += deviceJids.length;
+            merged[index] = {
+                jid,
+                deviceJids
+            };
+        }
         this.logger.debug('signal device sync success', {
             users: merged.length,
-            devices: merged.reduce((total, entry) => total + entry.deviceJids.length, 0)
+            devices: totalDevices
         });
         return merged;
     }
+    async queryLidsByPhoneJids(phoneJids, timeoutMs = this.defaultTimeoutMs) {
+        const normalizedPhoneJids = this.normalizeUsers(phoneJids);
+        if (normalizedPhoneJids.length === 0) {
+            return [];
+        }
+        const sid = await this.generateSid();
+        const request = this.makeLidSyncRequest(normalizedPhoneJids, sid);
+        this.logger.debug('signal lid sync request', {
+            users: normalizedPhoneJids.length,
+            timeoutMs
+        });
+        const response = await this.query(request, timeoutMs);
+        const parsed = this.parseLidSyncResponse(response, normalizedPhoneJids);
+        const parsedByPhoneJid = new Map();
+        for (let index = 0; index < parsed.length; index += 1) {
+            const entry = parsed[index];
+            const phoneJid = entry.phoneJid ?? entry.jid;
+            parsedByPhoneJid.set(phoneJid, {
+                phoneJid,
+                lidJid: entry.lidJid,
+                exists: entry.exists
+            });
+        }
+        const result = new Array(normalizedPhoneJids.length);
+        let found = 0;
+        for (let index = 0; index < normalizedPhoneJids.length; index += 1) {
+            const phoneJid = normalizedPhoneJids[index];
+            const resolved = parsedByPhoneJid.get(phoneJid) ?? {
+                phoneJid,
+                lidJid: null,
+                exists: false
+            };
+            if (resolved.exists) {
+                found += 1;
+            }
+            result[index] = resolved;
+        }
+        this.logger.debug('signal lid sync success', {
+            users: result.length,
+            found
+        });
+        return result;
+    }
     async collectUsersToQuery(normalizedUsers, nowMs, cachedByUser, store) {
         const records = await store.getUserDevicesBatch(normalizedUsers, nowMs);
         const usersToQuery = [];
@@ -71,41 +138,59 @@ class SignalDeviceSyncApi {
         }
         return usersToQuery;
     }
-    makeDeviceSyncRequest(userJids) {
-        return (0, query_1.buildIqNode)('get', this.hostDomain, constants_1.WA_XMLNS.USYNC, [
-            {
-                tag: constants_1.WA_NODE_TAGS.USYNC,
-                attrs: {
-                    sid: this.makeSid(),
-                    index: '0',
-                    last: 'true',
-                    mode: constants_1.WA_NODE_TAGS.QUERY,
-                    context: 'interactive'
-                },
+    makeDeviceSyncRequest(userJids, sid) {
+        const users = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            users[index] = {
+                jid: userJids[index]
+            };
+        }
+        return (0, usync_1.buildUsyncIq)({
+            sid,
+            hostDomain: this.hostDomain,
+            context: constants_1.WA_USYNC_CONTEXTS.INTERACTIVE,
+            queryProtocolNodes: [
+                {
+                    tag: constants_1.WA_NODE_TAGS.DEVICES,
+                    attrs: {
+                        version: '2'
+                    }
+                }
+            ],
+            users
+        });
+    }
+    makeLidSyncRequest(userJids, sid) {
+        const users = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            const jid = userJids[index];
+            users[index] = {
+                jid,
                 content: [
                     {
-                        tag: constants_1.WA_NODE_TAGS.QUERY,
-                        attrs: {},
-                        content: [
-                            {
-                                tag: constants_1.WA_NODE_TAGS.DEVICES,
-                                attrs: {
-                                    version: '2'
-                                }
-                            }
-                        ]
-                    },
-                    {
-                        tag: constants_1.WA_NODE_TAGS.LIST,
+                        tag: constants_1.WA_NODE_TAGS.CONTACT,
                         attrs: {},
-                        content: userJids.map((jid) => ({
-                            tag: constants_1.WA_NODE_TAGS.USER,
-                            attrs: { jid }
-                        }))
+                        content: (0, jid_1.splitJid)(jid).user
                     }
                 ]
-            }
-        ]);
+            };
+        }
+        return (0, usync_1.buildUsyncIq)({
+            sid,
+            hostDomain: this.hostDomain,
+            context: constants_1.WA_USYNC_CONTEXTS.INTERACTIVE,
+            queryProtocolNodes: [
+                {
+                    tag: constants_1.WA_NODE_TAGS.CONTACT,
+                    attrs: {}
+                },
+                {
+                    tag: constants_1.WA_NODE_TAGS.LID,
+                    attrs: {}
+                }
+            ],
+            users
+        });
     }
     parseDeviceSyncResponse(node, requestedUsers) {
         (0, query_1.assertIqResult)(node, 'signal device sync');
@@ -119,22 +204,95 @@ class SignalDeviceSyncApi {
         }
         const requestedSet = new Set(requestedUsers);
         const userNodes = (0, helpers_1.getNodeChildrenByTag)(listNode, constants_1.WA_NODE_TAGS.USER);
-        return userNodes.flatMap((userNode) => {
+        const parsed = [];
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
             const userJid = userNode.attrs.jid;
             if (!userJid) {
-                return [];
+                continue;
             }
             const normalizedUserJid = this.normalizeUserJid(userJid);
             if (!requestedSet.has(normalizedUserJid)) {
-                return [];
+                continue;
             }
-            return [
-                {
+            parsed.push({
+                jid: normalizedUserJid,
+                deviceJids: this.parseUserDeviceJids(userNode, normalizedUserJid)
+            });
+        }
+        return parsed;
+    }
+    parseLidSyncResponse(node, requestedUsers) {
+        (0, query_1.assertIqResult)(node, 'signal lid sync');
+        const usyncNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.USYNC);
+        if (!usyncNode) {
+            throw new Error('signal lid sync response missing usync node');
+        }
+        const listNode = (0, helpers_1.findNodeChild)(usyncNode, constants_1.WA_NODE_TAGS.LIST);
+        if (!listNode) {
+            throw new Error('signal lid sync response missing list node');
+        }
+        const requestedSet = new Set(requestedUsers);
+        const userNodes = (0, helpers_1.getNodeChildrenByTag)(listNode, constants_1.WA_NODE_TAGS.USER);
+        const parsed = [];
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
+            const userJid = userNode.attrs.jid;
+            if (!userJid) {
+                continue;
+            }
+            const normalizedUserJid = this.normalizeUserJid(userJid);
+            const normalizedPhoneJid = userNode.attrs.pn_jid
+                ? this.normalizeUserJid(userNode.attrs.pn_jid)
+                : null;
+            const wasRequested = requestedSet.has(normalizedUserJid) ||
+                (normalizedPhoneJid !== null && requestedSet.has(normalizedPhoneJid));
+            if (!wasRequested) {
+                continue;
+            }
+            const lidNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.LID);
+            const contactNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.CONTACT);
+            if (!lidNode) {
+                parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null));
+                continue;
+            }
+            const errorNode = (0, helpers_1.findNodeChild)(lidNode, constants_1.WA_NODE_TAGS.ERROR);
+            if (errorNode) {
+                this.logger.warn('signal lid sync user error', {
                     jid: normalizedUserJid,
-                    deviceJids: this.parseUserDeviceJids(userNode, normalizedUserJid)
-                }
-            ];
-        });
+                    code: errorNode.attrs.code,
+                    text: errorNode.attrs.text
+                });
+                parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null));
+                continue;
+            }
+            const lidJid = lidNode.attrs.val ? this.normalizeUserJid(lidNode.attrs.val) : null;
+            parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, lidJid));
+        }
+        return parsed;
+    }
+    buildLidSyncResult(jid, phoneJid, contactNode, lidJid) {
+        return {
+            jid,
+            lidJid,
+            phoneJid,
+            exists: this.parseLidSyncContactExists(contactNode, jid, lidJid !== null)
+        };
+    }
+    parseLidSyncContactExists(contactNode, userJid, defaultExists) {
+        if (!contactNode) {
+            return defaultExists;
+        }
+        const errorNode = (0, helpers_1.findNodeChild)(contactNode, constants_1.WA_NODE_TAGS.ERROR);
+        if (errorNode) {
+            this.logger.warn('signal lid sync contact error', {
+                jid: userJid,
+                code: errorNode.attrs.code,
+                text: errorNode.attrs.text
+            });
+            return false;
+        }
+        return contactNode.attrs.type === 'in';
     }
     parseUserDeviceJids(userNode, userJid) {
         const devicesNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.DEVICES);
@@ -154,36 +312,45 @@ class SignalDeviceSyncApi {
         if (!deviceListNode) {
             return [];
         }
-        return [
-            ...new Set((0, helpers_1.getNodeChildrenByTag)(deviceListNode, 'device')
-                .map((deviceNode) => {
-                const parsedId = deviceNode.attrs.id
-                    ? Number.parseInt(deviceNode.attrs.id, 10)
-                    : Number.NaN;
-                return Number.isSafeInteger(parsedId) && parsedId >= 0
-                    ? this.toDeviceJid(userJid, parsedId)
-                    : null;
-            })
-                .filter((jid) => jid !== null))
-        ];
+        const parsedUser = (0, jid_1.splitJid)(userJid);
+        const dedup = new Set();
+        for (const deviceNode of (0, helpers_1.getNodeChildrenByTag)(deviceListNode, 'device')) {
+            const parsedId = deviceNode.attrs.id
+                ? Number.parseInt(deviceNode.attrs.id, 10)
+                : Number.NaN;
+            if (!Number.isSafeInteger(parsedId) || parsedId < 0) {
+                continue;
+            }
+            dedup.add(this.toDeviceJid(parsedUser.user, parsedUser.server, parsedId));
+        }
+        const deviceJids = [];
+        for (const jid of dedup.values()) {
+            deviceJids.push(jid);
+        }
+        return deviceJids;
     }
     normalizeUsers(userJids) {
-        return [...new Set(userJids.map((jid) => this.normalizeUserJid(jid)))];
+        const normalized = [];
+        const dedup = new Set();
+        for (let index = 0; index < userJids.length; index += 1) {
+            const normalizedJid = this.normalizeUserJid(userJids[index]);
+            if (dedup.has(normalizedJid)) {
+                continue;
+            }
+            dedup.add(normalizedJid);
+            normalized.push(normalizedJid);
+        }
+        return normalized;
     }
     normalizeUserJid(jid) {
-        const { user } = (0, jid_1.parseSignalAddressFromJid)(jid);
-        const { server } = (0, jid_1.splitJid)(jid);
-        return `${user}@${server}`;
+        const address = (0, jid_1.parseSignalAddressFromJid)(jid);
+        return `${address.user}@${address.server}`;
     }
-    toDeviceJid(userJid, deviceId) {
-        const parsed = (0, jid_1.splitJid)(userJid);
+    toDeviceJid(user, server, deviceId) {
         if (deviceId === 0) {
-            return `${parsed.user}@${parsed.server}`;
+            return `${user}@${server}`;
         }
-        return `${parsed.user}:${deviceId}@${parsed.server}`;
-    }
-    makeSid() {
-        return `${Date.now()}.${(0, node_crypto_1.randomInt)(1000000)}`;
+        return `${user}:${deviceId}@${server}`;
     }
 }
 exports.SignalDeviceSyncApi = SignalDeviceSyncApi;

package/dist/signal/api/SignalDigestSyncApi.js

@@ -164,7 +164,12 @@ class SignalDigestSyncApi {
         const signedKeyId = (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(signedKeyIdNode.content, 'signal digest skey.id', constants_2.SIGNAL_KEY_ID_LENGTH), 'signal digest skey.id');
         const signedKeyPublicKey = (0, codec_1.decodeExactLength)(signedKeyValueNode.content, 'signal digest skey.value', constants_2.SIGNAL_KEY_DATA_LENGTH);
         const signedKeySignature = (0, codec_1.decodeExactLength)(signedKeySignatureNode.content, 'signal digest skey.signature', constants_2.SIGNAL_SIGNATURE_LENGTH);
-        const preKeyIds = (0, helpers_1.getNodeChildren)(listNode).map((child, index) => (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(child.content, `signal digest list[${index}]`, constants_2.SIGNAL_KEY_ID_LENGTH), `signal digest list[${index}]`));
+        const preKeyIds = [];
+        const listChildren = (0, helpers_1.getNodeChildren)(listNode);
+        for (let index = 0; index < listChildren.length; index += 1) {
+            const child = listChildren[index];
+            preKeyIds.push((0, codec_1.parseUint)((0, codec_1.decodeExactLength)(child.content, `signal digest list[${index}]`, constants_2.SIGNAL_KEY_ID_LENGTH), `signal digest list[${index}]`));
+        }
         const hash = (0, helpers_1.decodeNodeContentBase64OrBytes)(hashNode.content, 'signal digest hash');
         return {
             registrationId,

package/dist/signal/api/SignalIdentitySyncApi.js

@@ -7,6 +7,7 @@ const jid_1 = require("../../protocol/jid");
 const codec_1 = require("../api/codec");
 const constants_2 = require("../api/constants");
 const helpers_1 = require("../../transport/node/helpers");
+const query_1 = require("../../transport/node/query");
 class SignalIdentitySyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -17,10 +18,28 @@ class SignalIdentitySyncApi {
         this.hostDomain = options.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
     }
     async syncIdentityKeys(targetJids, timeoutMs = this.defaultTimeoutMs) {
-        const normalizedTargets = [...new Set(targetJids.map((jid) => (0, jid_1.normalizeDeviceJid)(jid)))];
+        const normalizedTargets = [];
+        const dedup = new Set();
+        for (let index = 0; index < targetJids.length; index += 1) {
+            const normalized = (0, jid_1.normalizeDeviceJid)(targetJids[index]);
+            if (dedup.has(normalized)) {
+                continue;
+            }
+            dedup.add(normalized);
+            normalizedTargets.push(normalized);
+        }
         if (normalizedTargets.length === 0) {
             return [];
         }
+        const users = new Array(normalizedTargets.length);
+        for (let index = 0; index < normalizedTargets.length; index += 1) {
+            users[index] = {
+                tag: constants_1.WA_NODE_TAGS.USER,
+                attrs: {
+                    jid: normalizedTargets[index]
+                }
+            };
+        }
         this.logger.debug('signal identity sync request', {
             targets: normalizedTargets.length,
             timeoutMs
@@ -36,20 +55,22 @@ class SignalIdentitySyncApi {
                 {
                     tag: constants_1.WA_NODE_TAGS.IDENTITY,
                     attrs: {},
-                    content: normalizedTargets.map((jid) => ({
-                        tag: constants_1.WA_NODE_TAGS.USER,
-                        attrs: { jid }
-                    }))
+                    content: users
                 }
             ]
         }, timeoutMs);
         const entries = this.parseIdentitySyncResponse(response, normalizedTargets);
         const { signalStore } = this;
         if (signalStore && entries.length > 0) {
-            await signalStore.setRemoteIdentities(entries.map((entry) => ({
-                address: (0, jid_1.parseSignalAddressFromJid)(entry.jid),
-                identityKey: (0, keys_1.toSerializedPubKey)(entry.identity)
-            })));
+            const identities = new Array(entries.length);
+            for (let index = 0; index < entries.length; index += 1) {
+                const entry = entries[index];
+                identities[index] = {
+                    address: (0, jid_1.parseSignalAddressFromJid)(entry.jid),
+                    identityKey: (0, keys_1.toSerializedPubKey)(entry.identity)
+                };
+            }
+            await signalStore.setRemoteIdentities(identities);
         }
         this.logger.debug('signal identity sync success', {
             requested: normalizedTargets.length,
@@ -58,31 +79,19 @@ class SignalIdentitySyncApi {
         return entries;
     }
     parseIdentitySyncResponse(node, requestedJids) {
-        if (node.tag !== constants_1.WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid identity sync response tag: ${node.tag}`);
-        }
-        if (node.attrs.type === constants_1.WA_IQ_TYPES.ERROR) {
-            const errorNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.ERROR);
-            if (!errorNode) {
-                throw new Error(`identity sync iq error for ${node.attrs.id ?? 'unknown id'}`);
-            }
-            const code = errorNode.attrs.code ?? 'unknown';
-            const text = errorNode.attrs.text ?? errorNode.attrs.type ?? 'unknown';
-            throw new Error(`identity sync iq error (${code} ${text})`);
-        }
-        if (node.attrs.type !== constants_1.WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid identity sync response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        (0, query_1.assertIqResult)(node, 'identity sync');
         const listNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('identity sync response missing list node');
         }
         const requested = new Set(requestedJids);
         const userNodes = (0, helpers_1.getNodeChildrenByTag)(listNode, constants_1.WA_NODE_TAGS.USER);
-        return userNodes.flatMap((userNode) => {
+        const parsed = [];
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
             const jid = userNode.attrs.jid ? (0, jid_1.normalizeDeviceJid)(userNode.attrs.jid) : '';
             if (!jid || !requested.has(jid)) {
-                return [];
+                continue;
             }
             const errorNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.ERROR);
             if (errorNode) {
@@ -91,7 +100,7 @@ class SignalIdentitySyncApi {
                     code: errorNode.attrs.code,
                     text: errorNode.attrs.text
                 });
-                return [];
+                continue;
             }
             const identityNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.IDENTITY);
             if (!identityNode) {
@@ -102,14 +111,20 @@ class SignalIdentitySyncApi {
             const parsedType = typeNode
                 ? (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(typeNode.content, 'identity sync type', constants_2.SIGNAL_KEY_BUNDLE_TYPE_LENGTH), 'identity sync type')
                 : undefined;
-            return [
-                {
+            if (parsedType === undefined) {
+                parsed.push({
                     jid,
-                    identity,
-                    ...(parsedType !== undefined ? { type: parsedType } : {})
-                }
-            ];
-        });
+                    identity
+                });
+                continue;
+            }
+            parsed.push({
+                jid,
+                identity,
+                type: parsedType
+            });
+        }
+        return parsed;
     }
 }
 exports.SignalIdentitySyncApi = SignalIdentitySyncApi;