zapo-js 0.1.1 → 0.2.0

package/dist/esm/signal/api/SignalDeviceSyncApi.js

@@ -1,34 +1,48 @@
-import { randomInt } from 'node:crypto';
-import { WA_DEFAULTS, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
-import { parseSignalAddressFromJid, splitJid } from '../../protocol/jid.js';
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { WA_DEFAULTS, WA_NODE_TAGS, WA_USYNC_CONTEXTS } from '../../protocol/constants.js';
+import { buildDeviceJid, isHostedDeviceId, splitJid, toUserJid } from '../../protocol/jid.js';
+import { buildUsyncIq } from '../../transport/node/builders/usync.js';
 import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
-import { assertIqResult, buildIqNode } from '../../transport/node/query.js';
+import { assertIqResult } from '../../transport/node/query.js';
+import { createUsyncSidGenerator } from '../../transport/node/usync.js';
 export class SignalDeviceSyncApi {
     constructor(options) {
+        this.syncDedup = new PromiseDedup();
         this.logger = options.logger;
         this.query = options.query;
         this.deviceListStore = options.deviceListStore;
         this.defaultTimeoutMs =
             options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
+        this.generateSid = options.generateSid ?? createUsyncSidGenerator();
     }
-    async syncDeviceList(userJids, timeoutMs = this.defaultTimeoutMs) {
+    syncDeviceList(userJids, timeoutMs = this.defaultTimeoutMs) {
         const normalizedUsers = this.normalizeUsers(userJids);
         if (normalizedUsers.length === 0) {
-            return [];
+            return Promise.resolve([]);
         }
+        const dedupKey = normalizedUsers.join(',');
+        return this.syncDedup.run(dedupKey, () => this.syncDeviceListInternal(normalizedUsers, timeoutMs));
+    }
+    async syncDeviceListInternal(normalizedUsers, timeoutMs) {
         const nowMs = Date.now();
         const cachedByUser = new Map();
         const usersToQuery = this.deviceListStore
             ? 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
@@ -37,72 +51,152 @@ export 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 = [];
+        const usersToQuery = new Array(normalizedUsers.length);
+        let usersToQueryCount = 0;
         for (let index = 0; index < normalizedUsers.length; index += 1) {
             const userJid = normalizedUsers[index];
             const record = records[index];
             if (!record) {
-                usersToQuery.push(userJid);
+                usersToQuery[usersToQueryCount] = userJid;
+                usersToQueryCount += 1;
                 continue;
             }
             cachedByUser.set(userJid, record.deviceJids);
         }
+        usersToQuery.length = usersToQueryCount;
         return usersToQuery;
     }
-    makeDeviceSyncRequest(userJids) {
-        return buildIqNode('get', this.hostDomain, WA_XMLNS.USYNC, [
-            {
-                tag: WA_NODE_TAGS.USYNC,
-                attrs: {
-                    sid: this.makeSid(),
-                    index: '0',
-                    last: 'true',
-                    mode: 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 buildUsyncIq({
+            sid,
+            hostDomain: this.hostDomain,
+            context: WA_USYNC_CONTEXTS.INTERACTIVE,
+            queryProtocolNodes: [
+                {
+                    tag: 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: WA_NODE_TAGS.QUERY,
+                        tag: WA_NODE_TAGS.CONTACT,
                         attrs: {},
-                        content: [
-                            {
-                                tag: WA_NODE_TAGS.DEVICES,
-                                attrs: {
-                                    version: '2'
-                                }
-                            }
-                        ]
-                    },
-                    {
-                        tag: WA_NODE_TAGS.LIST,
-                        attrs: {},
-                        content: userJids.map((jid) => ({
-                            tag: WA_NODE_TAGS.USER,
-                            attrs: { jid }
-                        }))
+                        content: splitJid(jid).user
                     }
                 ]
-            }
-        ]);
+            };
+        }
+        return buildUsyncIq({
+            sid,
+            hostDomain: this.hostDomain,
+            context: WA_USYNC_CONTEXTS.INTERACTIVE,
+            queryProtocolNodes: [
+                {
+                    tag: WA_NODE_TAGS.CONTACT,
+                    attrs: {}
+                },
+                {
+                    tag: WA_NODE_TAGS.LID,
+                    attrs: {}
+                }
+            ],
+            users
+        });
     }
     parseDeviceSyncResponse(node, requestedUsers) {
         assertIqResult(node, 'signal device sync');
@@ -116,24 +210,105 @@ export class SignalDeviceSyncApi {
         }
         const requestedSet = new Set(requestedUsers);
         const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
-        return userNodes.flatMap((userNode) => {
+        const parsed = new Array(userNodes.length);
+        let parsedCount = 0;
+        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[parsedCount] = {
+                jid: normalizedUserJid,
+                deviceJids: this.parseUserDeviceJids(userNode, userJid, normalizedUserJid)
+            };
+            parsedCount += 1;
+        }
+        parsed.length = parsedCount;
+        return parsed;
+    }
+    parseLidSyncResponse(node, requestedUsers) {
+        assertIqResult(node, 'signal lid sync');
+        const usyncNode = findNodeChild(node, WA_NODE_TAGS.USYNC);
+        if (!usyncNode) {
+            throw new Error('signal lid sync response missing usync node');
+        }
+        const listNode = findNodeChild(usyncNode, WA_NODE_TAGS.LIST);
+        if (!listNode) {
+            throw new Error('signal lid sync response missing list node');
+        }
+        const requestedSet = new Set(requestedUsers);
+        const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
+        const parsed = new Array(userNodes.length);
+        let parsedCount = 0;
+        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 = findNodeChild(userNode, WA_NODE_TAGS.LID);
+            const contactNode = findNodeChild(userNode, WA_NODE_TAGS.CONTACT);
+            if (!lidNode) {
+                parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
+                parsedCount += 1;
+                continue;
+            }
+            const errorNode = findNodeChild(lidNode, 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[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
+                parsedCount += 1;
+                continue;
+            }
+            const lidJid = lidNode.attrs.val ? this.normalizeUserJid(lidNode.attrs.val) : null;
+            parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, lidJid);
+            parsedCount += 1;
+        }
+        parsed.length = parsedCount;
+        return parsed;
     }
-    parseUserDeviceJids(userNode, userJid) {
+    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 = findNodeChild(contactNode, 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, rawUserJid, normalizedUserJid) {
         const devicesNode = findNodeChild(userNode, WA_NODE_TAGS.DEVICES);
         if (!devicesNode) {
             return [];
@@ -141,7 +316,7 @@ export class SignalDeviceSyncApi {
         const errorNode = findNodeChild(devicesNode, WA_NODE_TAGS.ERROR);
         if (errorNode) {
             this.logger.warn('signal device sync user error', {
-                jid: userJid,
+                jid: normalizedUserJid,
                 code: errorNode.attrs.code,
                 text: errorNode.attrs.text
             });
@@ -151,35 +326,44 @@ export class SignalDeviceSyncApi {
         if (!deviceListNode) {
             return [];
         }
-        return [
-            ...new Set(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 parsedNormalizedUser = splitJid(normalizedUserJid);
+        const parsedRawUser = splitJid(rawUserJid);
+        const dedup = new Set();
+        for (const deviceNode of getNodeChildrenByTag(deviceListNode, 'device')) {
+            const parsedId = deviceNode.attrs.id
+                ? Number.parseInt(deviceNode.attrs.id, 10)
+                : Number.NaN;
+            if (!Number.isSafeInteger(parsedId) || parsedId < 0) {
+                continue;
+            }
+            const isHostedDevice = isHostedDeviceId(parsedId) || deviceNode.attrs.is_hosted === 'true';
+            dedup.add(buildDeviceJid(parsedNormalizedUser.user, parsedNormalizedUser.server, parsedId, {
+                rawServer: parsedRawUser.server,
+                isHosted: isHostedDevice
+            }));
+        }
+        return Array.from(dedup);
     }
     normalizeUsers(userJids) {
-        return [...new Set(userJids.map((jid) => this.normalizeUserJid(jid)))];
-    }
-    normalizeUserJid(jid) {
-        const { user } = parseSignalAddressFromJid(jid);
-        const { server } = splitJid(jid);
-        return `${user}@${server}`;
-    }
-    toDeviceJid(userJid, deviceId) {
-        const parsed = splitJid(userJid);
-        if (deviceId === 0) {
-            return `${parsed.user}@${parsed.server}`;
+        const normalized = new Array(userJids.length);
+        let normalizedCount = 0;
+        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[normalizedCount] = normalizedJid;
+            normalizedCount += 1;
         }
-        return `${parsed.user}:${deviceId}@${parsed.server}`;
+        normalized.length = normalizedCount;
+        return normalized;
     }
-    makeSid() {
-        return `${Date.now()}.${randomInt(1000000)}`;
+    normalizeUserJid(jid) {
+        return toUserJid(jid, {
+            canonicalizeSignalServer: true,
+            hostDomain: this.hostDomain
+        });
     }
 }

package/dist/esm/signal/api/SignalDigestSyncApi.js

@@ -14,8 +14,10 @@ export class SignalDigestSyncApi {
             options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
     }
-    async validateLocalKeyBundle(timeoutMs = this.defaultTimeoutMs) {
-        this.logger.debug('signal digest query request', { timeoutMs });
+    async validateLocalKeyBundle(prefetchedOrTimeout, timeoutMs = this.defaultTimeoutMs) {
+        const prefetched = typeof prefetchedOrTimeout === 'number' ? undefined : prefetchedOrTimeout;
+        const effectiveTimeoutMs = typeof prefetchedOrTimeout === 'number' ? prefetchedOrTimeout : timeoutMs;
+        this.logger.debug('signal digest query request', { timeoutMs: effectiveTimeoutMs });
         const response = await this.query({
             tag: WA_NODE_TAGS.IQ,
             attrs: {
@@ -29,7 +31,7 @@ export class SignalDigestSyncApi {
                     attrs: {}
                 }
             ]
-        }, timeoutMs);
+        }, effectiveTimeoutMs);
         if (response.tag !== WA_NODE_TAGS.IQ) {
             throw new Error(`invalid signal digest response tag: ${response.tag}`);
         }
@@ -58,10 +60,12 @@ export class SignalDigestSyncApi {
                 preKeyCount: digest.preKeyIds.length
             };
         }
-        const [registrationInfo, signedPreKey] = await Promise.all([
-            this.signalStore.getRegistrationInfo(),
-            this.signalStore.getSignedPreKey()
-        ]);
+        const [registrationInfo, signedPreKey] = prefetched
+            ? [prefetched.registrationInfo, prefetched.signedPreKey]
+            : await Promise.all([
+                this.signalStore.getRegistrationInfo(),
+                this.signalStore.getSignedPreKey()
+            ]);
         if (!registrationInfo || !signedPreKey) {
             return {
                 valid: false,
@@ -161,7 +165,12 @@ export class SignalDigestSyncApi {
         const signedKeyId = parseUint(decodeExactLength(signedKeyIdNode.content, 'signal digest skey.id', SIGNAL_KEY_ID_LENGTH), 'signal digest skey.id');
         const signedKeyPublicKey = decodeExactLength(signedKeyValueNode.content, 'signal digest skey.value', SIGNAL_KEY_DATA_LENGTH);
         const signedKeySignature = decodeExactLength(signedKeySignatureNode.content, 'signal digest skey.signature', SIGNAL_SIGNATURE_LENGTH);
-        const preKeyIds = getNodeChildren(listNode).map((child, index) => parseUint(decodeExactLength(child.content, `signal digest list[${index}]`, SIGNAL_KEY_ID_LENGTH), `signal digest list[${index}]`));
+        const listChildren = getNodeChildren(listNode);
+        const preKeyIds = new Array(listChildren.length);
+        for (let index = 0; index < listChildren.length; index += 1) {
+            const child = listChildren[index];
+            preKeyIds[index] = parseUint(decodeExactLength(child.content, `signal digest list[${index}]`, SIGNAL_KEY_ID_LENGTH), `signal digest list[${index}]`);
+        }
         const hash = decodeNodeContentBase64OrBytes(hashNode.content, 'signal digest hash');
         return {
             registrationId,

package/dist/esm/signal/api/SignalIdentitySyncApi.js

@@ -1,11 +1,14 @@
 import { toSerializedPubKey } from '../../crypto/core/keys.js';
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
-import { normalizeDeviceJid, parseSignalAddressFromJid } from '../../protocol/jid.js';
+import { canonicalizeSignalJid, parseSignalAddressFromJid } from '../../protocol/jid.js';
 import { decodeExactLength, parseUint } from '../api/codec.js';
 import { SIGNAL_KEY_BUNDLE_TYPE_LENGTH, SIGNAL_KEY_DATA_LENGTH } from '../api/constants.js';
 import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { assertIqResult } from '../../transport/node/query.js';
 export class SignalIdentitySyncApi {
     constructor(options) {
+        this.syncDedup = new PromiseDedup();
         this.logger = options.logger;
         this.query = options.query;
         this.signalStore = options.signalStore;
@@ -13,11 +16,36 @@ export class SignalIdentitySyncApi {
             options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
     }
-    async syncIdentityKeys(targetJids, timeoutMs = this.defaultTimeoutMs) {
-        const normalizedTargets = [...new Set(targetJids.map((jid) => normalizeDeviceJid(jid)))];
+    syncIdentityKeys(targetJids, timeoutMs = this.defaultTimeoutMs) {
+        const dedupKey = `${timeoutMs}:${targetJids.join(',')}`;
+        return this.syncDedup.run(dedupKey, () => this.syncIdentityKeysInternal(targetJids, timeoutMs));
+    }
+    async syncIdentityKeysInternal(targetJids, timeoutMs) {
+        const normalizedTargets = new Array(targetJids.length);
+        let normalizedTargetsCount = 0;
+        const dedup = new Set();
+        for (let index = 0; index < targetJids.length; index += 1) {
+            const normalized = canonicalizeSignalJid(targetJids[index], this.hostDomain);
+            if (dedup.has(normalized)) {
+                continue;
+            }
+            dedup.add(normalized);
+            normalizedTargets[normalizedTargetsCount] = normalized;
+            normalizedTargetsCount += 1;
+        }
+        normalizedTargets.length = normalizedTargetsCount;
         if (normalizedTargets.length === 0) {
             return [];
         }
+        const users = new Array(normalizedTargets.length);
+        for (let index = 0; index < normalizedTargets.length; index += 1) {
+            users[index] = {
+                tag: WA_NODE_TAGS.USER,
+                attrs: {
+                    jid: normalizedTargets[index]
+                }
+            };
+        }
         this.logger.debug('signal identity sync request', {
             targets: normalizedTargets.length,
             timeoutMs
@@ -33,20 +61,22 @@ export class SignalIdentitySyncApi {
                 {
                     tag: WA_NODE_TAGS.IDENTITY,
                     attrs: {},
-                    content: normalizedTargets.map((jid) => ({
-                        tag: 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: parseSignalAddressFromJid(entry.jid),
-                identityKey: 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: parseSignalAddressFromJid(entry.jid),
+                    identityKey: toSerializedPubKey(entry.identity)
+                };
+            }
+            await signalStore.setRemoteIdentities(identities);
         }
         this.logger.debug('signal identity sync success', {
             requested: normalizedTargets.length,
@@ -55,31 +85,22 @@ export class SignalIdentitySyncApi {
         return entries;
     }
     parseIdentitySyncResponse(node, requestedJids) {
-        if (node.tag !== WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid identity sync response tag: ${node.tag}`);
-        }
-        if (node.attrs.type === WA_IQ_TYPES.ERROR) {
-            const errorNode = findNodeChild(node, 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 !== WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid identity sync response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        assertIqResult(node, 'identity sync');
         const listNode = findNodeChild(node, WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('identity sync response missing list node');
         }
         const requested = new Set(requestedJids);
         const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
-        return userNodes.flatMap((userNode) => {
-            const jid = userNode.attrs.jid ? normalizeDeviceJid(userNode.attrs.jid) : '';
+        const parsed = new Array(userNodes.length);
+        let parsedCount = 0;
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
+            const jid = userNode.attrs.jid
+                ? canonicalizeSignalJid(userNode.attrs.jid, this.hostDomain)
+                : '';
             if (!jid || !requested.has(jid)) {
-                return [];
+                continue;
             }
             const errorNode = findNodeChild(userNode, WA_NODE_TAGS.ERROR);
             if (errorNode) {
@@ -88,7 +109,7 @@ export class SignalIdentitySyncApi {
                     code: errorNode.attrs.code,
                     text: errorNode.attrs.text
                 });
-                return [];
+                continue;
             }
             const identityNode = findNodeChild(userNode, WA_NODE_TAGS.IDENTITY);
             if (!identityNode) {
@@ -99,13 +120,22 @@ export class SignalIdentitySyncApi {
             const parsedType = typeNode
                 ? parseUint(decodeExactLength(typeNode.content, 'identity sync type', SIGNAL_KEY_BUNDLE_TYPE_LENGTH), 'identity sync type')
                 : undefined;
-            return [
-                {
+            if (parsedType === undefined) {
+                parsed[parsedCount] = {
                     jid,
-                    identity,
-                    ...(parsedType !== undefined ? { type: parsedType } : {})
-                }
-            ];
-        });
+                    identity
+                };
+                parsedCount += 1;
+                continue;
+            }
+            parsed[parsedCount] = {
+                jid,
+                identity,
+                type: parsedType
+            };
+            parsedCount += 1;
+        }
+        parsed.length = parsedCount;
+        return parsed;
     }
 }