zapo-js 0.1.1 → 0.2.0

package/dist/signal/api/SignalDeviceSyncApi.js

@@ -1,37 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalDeviceSyncApi = void 0;
-const node_crypto_1 = require("node:crypto");
+const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
 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.syncDedup = new PromiseDedup_1.PromiseDedup();
         this.logger = options.logger;
         this.query = options.query;
         this.deviceListStore = options.deviceListStore;
         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) {
+    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
@@ -40,72 +54,152 @@ 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 (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,
+                        tag: constants_1.WA_NODE_TAGS.CONTACT,
                         attrs: {},
-                        content: [
-                            {
-                                tag: constants_1.WA_NODE_TAGS.DEVICES,
-                                attrs: {
-                                    version: '2'
-                                }
-                            }
-                        ]
-                    },
-                    {
-                        tag: constants_1.WA_NODE_TAGS.LIST,
-                        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,24 +213,105 @@ 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 = 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) {
+        (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 = 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 = (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[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
+                parsedCount += 1;
+                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[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 = (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, rawUserJid, normalizedUserJid) {
         const devicesNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.DEVICES);
         if (!devicesNode) {
             return [];
@@ -144,7 +319,7 @@ class SignalDeviceSyncApi {
         const errorNode = (0, helpers_1.findNodeChild)(devicesNode, constants_1.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
             });
@@ -154,36 +329,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 parsedNormalizedUser = (0, jid_1.splitJid)(normalizedUserJid);
+        const parsedRawUser = (0, jid_1.splitJid)(rawUserJid);
+        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;
+            }
+            const isHostedDevice = (0, jid_1.isHostedDeviceId)(parsedId) || deviceNode.attrs.is_hosted === 'true';
+            dedup.add((0, jid_1.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 } = (0, jid_1.parseSignalAddressFromJid)(jid);
-        const { server } = (0, jid_1.splitJid)(jid);
-        return `${user}@${server}`;
-    }
-    toDeviceJid(userJid, deviceId) {
-        const parsed = (0, jid_1.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()}.${(0, node_crypto_1.randomInt)(1000000)}`;
+    normalizeUserJid(jid) {
+        return (0, jid_1.toUserJid)(jid, {
+            canonicalizeSignalServer: true,
+            hostDomain: this.hostDomain
+        });
     }
 }
 exports.SignalDeviceSyncApi = SignalDeviceSyncApi;

package/dist/signal/api/SignalDigestSyncApi.js

@@ -17,8 +17,10 @@ class SignalDigestSyncApi {
             options.defaultTimeoutMs ?? constants_1.WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? constants_1.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: constants_1.WA_NODE_TAGS.IQ,
             attrs: {
@@ -32,7 +34,7 @@ class SignalDigestSyncApi {
                     attrs: {}
                 }
             ]
-        }, timeoutMs);
+        }, effectiveTimeoutMs);
         if (response.tag !== constants_1.WA_NODE_TAGS.IQ) {
             throw new Error(`invalid signal digest response tag: ${response.tag}`);
         }
@@ -61,10 +63,12 @@ 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,
@@ -164,7 +168,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 listChildren = (0, helpers_1.getNodeChildren)(listNode);
+        const preKeyIds = new Array(listChildren.length);
+        for (let index = 0; index < listChildren.length; index += 1) {
+            const child = listChildren[index];
+            preKeyIds[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 hash = (0, helpers_1.decodeNodeContentBase64OrBytes)(hashNode.content, 'signal digest hash');
         return {
             registrationId,