zapo-js 0.1.1 → 0.2.0

package/dist/signal/api/SignalIdentitySyncApi.js

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalIdentitySyncApi = void 0;
 const keys_1 = require("../../crypto/core/keys");
+const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
 const constants_1 = require("../../protocol/constants");
 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.syncDedup = new PromiseDedup_1.PromiseDedup();
         this.logger = options.logger;
         this.query = options.query;
         this.signalStore = options.signalStore;
@@ -16,11 +19,36 @@ class SignalIdentitySyncApi {
             options.defaultTimeoutMs ?? constants_1.WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         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)))];
+    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 = (0, jid_1.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: constants_1.WA_NODE_TAGS.USER,
+                attrs: {
+                    jid: normalizedTargets[index]
+                }
+            };
+        }
         this.logger.debug('signal identity sync request', {
             targets: normalizedTargets.length,
             timeoutMs
@@ -36,20 +64,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 +88,22 @@ 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 jid = userNode.attrs.jid ? (0, jid_1.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
+                ? (0, jid_1.canonicalizeSignalJid)(userNode.attrs.jid, this.hostDomain)
+                : '';
             if (!jid || !requested.has(jid)) {
-                return [];
+                continue;
             }
             const errorNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.ERROR);
             if (errorNode) {
@@ -91,7 +112,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 +123,23 @@ 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[parsedCount] = {
                     jid,
-                    identity,
-                    ...(parsedType !== undefined ? { type: parsedType } : {})
-                }
-            ];
-        });
+                    identity
+                };
+                parsedCount += 1;
+                continue;
+            }
+            parsed[parsedCount] = {
+                jid,
+                identity,
+                type: parsedType
+            };
+            parsedCount += 1;
+        }
+        parsed.length = parsedCount;
+        return parsed;
     }
 }
 exports.SignalIdentitySyncApi = SignalIdentitySyncApi;

package/dist/signal/api/SignalMissingPreKeysSyncApi.js

@@ -6,17 +6,11 @@ const jid_1 = require("../../protocol/jid");
 const codec_1 = require("../api/codec");
 const constants_2 = require("../api/constants");
 const prekeys_1 = require("../api/prekeys");
+const result_map_1 = require("../api/result-map");
 const helpers_1 = require("../../transport/node/helpers");
 const query_1 = require("../../transport/node/query");
-function parseDeviceId(value, field) {
-    if (!value) {
-        throw new Error(`${field} is missing`);
-    }
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isSafeInteger(parsed) || parsed < 0) {
-        throw new Error(`${field} is invalid`);
-    }
-    return parsed;
+function isMissingPreKeysUserResultPreferred(result) {
+    return 'devices' in result;
 }
 class SignalMissingPreKeysSyncApi {
     constructor(options) {
@@ -41,105 +35,130 @@ class SignalMissingPreKeysSyncApi {
         return parsed;
     }
     parseFetchMissingPreKeysResponse(node, requestedTargets) {
-        if (node.tag !== constants_1.WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid missing prekeys response tag: ${node.tag}`);
-        }
-        if (node.attrs.type === constants_1.WA_IQ_TYPES.ERROR) {
-            const error = (0, query_1.parseIqError)(node);
-            throw new Error(`missing prekeys iq failed (${error.code}: ${error.text})`);
-        }
-        if (node.attrs.type !== constants_1.WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid missing prekeys response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        (0, query_1.assertIqResult)(node, 'missing prekeys');
         const listNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('missing prekeys response missing list node');
         }
         const users = (0, helpers_1.getNodeChildrenByTag)(listNode, constants_1.WA_NODE_TAGS.USER);
         const parsedByJid = new Map();
+        const parsedByCanonicalJid = new Map();
         for (let index = 0; index < users.length; index += 1) {
             const userNode = users[index];
             const userJid = userNode.attrs.jid;
             if (!userJid) {
                 continue;
             }
+            const canonicalUserJid = (0, jid_1.toUserJid)(userJid, {
+                canonicalizeSignalServer: true
+            });
             const userErrorNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.ERROR);
             if (userErrorNode) {
                 const parsedCode = Number.parseInt(userErrorNode.attrs.code ?? '', 10);
-                parsedByJid.set(userJid, {
+                (0, result_map_1.registerParsedResultByRawAndCanonicalKey)(parsedByJid, parsedByCanonicalJid, userJid, canonicalUserJid, {
                     userJid,
                     errorCode: Number.isSafeInteger(parsedCode) ? parsedCode : undefined,
                     errorText: userErrorNode.attrs.text ?? userErrorNode.attrs.type ?? 'unknown'
-                });
+                }, isMissingPreKeysUserResultPreferred);
                 continue;
             }
-            parsedByJid.set(userJid, {
+            (0, result_map_1.registerParsedResultByRawAndCanonicalKey)(parsedByJid, parsedByCanonicalJid, userJid, canonicalUserJid, {
                 userJid,
-                devices: this.parseUserDevices(userNode, userJid)
-            });
+                devices: this.parseUserDevices(userNode, canonicalUserJid)
+            }, isMissingPreKeysUserResultPreferred);
         }
-        return requestedTargets.map((target) => {
-            return (parsedByJid.get(target.userJid) ?? {
+        const results = new Array(requestedTargets.length);
+        for (let index = 0; index < requestedTargets.length; index += 1) {
+            const target = requestedTargets[index];
+            results[index] = parsedByJid.get(target.userJid) ??
+                parsedByCanonicalJid.get((0, jid_1.toUserJid)(target.userJid, {
+                    canonicalizeSignalServer: true
+                })) ?? {
                 userJid: target.userJid,
                 errorText: 'missing user in key_fetch response'
-            });
-        });
+            };
+        }
+        return results;
     }
     parseUserDevices(node, userJid) {
         const { user, server } = (0, jid_1.splitJid)(userJid);
         const devices = (0, helpers_1.getNodeChildrenByTag)(node, constants_1.WA_NODE_TAGS.DEVICE);
-        return devices.map((deviceNode, index) => {
-            const deviceId = parseDeviceId(deviceNode.attrs.id, `missing prekeys user[${userJid}] device[${index}].id`);
-            const registrationNode = (0, helpers_1.findNodeChild)(deviceNode, constants_1.WA_NODE_TAGS.REGISTRATION);
-            const identityNode = (0, helpers_1.findNodeChild)(deviceNode, constants_1.WA_NODE_TAGS.IDENTITY);
-            const signedKeyNode = (0, helpers_1.findNodeChild)(deviceNode, constants_1.WA_NODE_TAGS.SKEY);
+        const bundles = new Array(devices.length);
+        for (let index = 0; index < devices.length; index += 1) {
+            const deviceNode = devices[index];
+            const deviceIdValue = deviceNode.attrs.id;
+            if (!deviceIdValue) {
+                throw new Error(`missing prekeys device[${index}].id is missing`);
+            }
+            const deviceId = Number.parseInt(deviceIdValue, 10);
+            if (!Number.isSafeInteger(deviceId) || deviceId < 0) {
+                throw new Error(`missing prekeys device[${index}].id is invalid`);
+            }
+            const [registrationNode, identityNode, signedKeyNode, oneTimeNode, deviceIdentityNode] = (0, helpers_1.findNodeChildrenByTags)(deviceNode, [
+                constants_1.WA_NODE_TAGS.REGISTRATION,
+                constants_1.WA_NODE_TAGS.IDENTITY,
+                constants_1.WA_NODE_TAGS.SKEY,
+                constants_1.WA_NODE_TAGS.KEY,
+                constants_1.WA_NODE_TAGS.DEVICE_IDENTITY
+            ]);
             if (!registrationNode || !identityNode || !signedKeyNode) {
                 throw new Error(`missing prekeys device payload is incomplete for ${userJid}`);
             }
-            const signedKeyIdNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.ID);
-            const signedKeyValueNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.VALUE);
-            const signedKeySignatureNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.SIGNATURE);
+            const [signedKeyIdNode, signedKeyValueNode, signedKeySignatureNode] = (0, helpers_1.findNodeChildrenByTags)(signedKeyNode, [
+                constants_1.WA_NODE_TAGS.ID,
+                constants_1.WA_NODE_TAGS.VALUE,
+                constants_1.WA_NODE_TAGS.SIGNATURE
+            ]);
             if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
                 throw new Error(`missing prekeys signed pre-key is incomplete for ${userJid}`);
             }
-            const oneTimeNode = (0, helpers_1.findNodeChild)(deviceNode, constants_1.WA_NODE_TAGS.KEY);
-            const oneTimeIdNode = oneTimeNode
-                ? (0, helpers_1.findNodeChild)(oneTimeNode, constants_1.WA_NODE_TAGS.ID)
-                : undefined;
-            const oneTimeValueNode = oneTimeNode
-                ? (0, helpers_1.findNodeChild)(oneTimeNode, constants_1.WA_NODE_TAGS.VALUE)
-                : undefined;
+            let oneTimeIdNode;
+            let oneTimeValueNode;
+            if (oneTimeNode) {
+                const oneTimeNodes = (0, helpers_1.findNodeChildrenByTags)(oneTimeNode, [
+                    constants_1.WA_NODE_TAGS.ID,
+                    constants_1.WA_NODE_TAGS.VALUE
+                ]);
+                oneTimeIdNode = oneTimeNodes[0];
+                oneTimeValueNode = oneTimeNodes[1];
+            }
             if (oneTimeNode && (!oneTimeIdNode || !oneTimeValueNode)) {
                 throw new Error(`missing prekeys one-time key is incomplete for ${userJid}`);
             }
-            const deviceIdentityNode = (0, helpers_1.findNodeChild)(deviceNode, constants_1.WA_NODE_TAGS.DEVICE_IDENTITY);
-            const bundle = {
+            const baseBundle = {
                 regId: (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(registrationNode.content, 'missing prekeys device registration', constants_2.SIGNAL_REGISTRATION_ID_LENGTH), 'missing prekeys device registration'),
                 identity: (0, codec_1.decodeExactLength)(identityNode.content, 'missing prekeys device identity', constants_2.SIGNAL_KEY_DATA_LENGTH),
                 signedKey: {
                     id: (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(signedKeyIdNode.content, 'missing prekeys device skey.id', constants_2.SIGNAL_KEY_ID_LENGTH), 'missing prekeys device skey.id'),
                     publicKey: (0, codec_1.decodeExactLength)(signedKeyValueNode.content, 'missing prekeys device skey.value', constants_2.SIGNAL_KEY_DATA_LENGTH),
                     signature: (0, codec_1.decodeExactLength)(signedKeySignatureNode.content, 'missing prekeys device skey.signature', constants_2.SIGNAL_SIGNATURE_LENGTH)
-                },
-                ...(oneTimeIdNode && oneTimeValueNode
-                    ? {
-                        oneTimeKey: {
-                            id: (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(oneTimeIdNode.content, 'missing prekeys device key.id', constants_2.SIGNAL_KEY_ID_LENGTH), 'missing prekeys device key.id'),
-                            publicKey: (0, codec_1.decodeExactLength)(oneTimeValueNode.content, 'missing prekeys device key.value', constants_2.SIGNAL_KEY_DATA_LENGTH)
-                        }
-                    }
-                    : {})
+                }
             };
-            return {
-                deviceJid: deviceId === 0 ? userJid : `${user}:${deviceId}@${server}`,
-                bundle,
-                ...(deviceIdentityNode
-                    ? {
-                        deviceIdentity: (0, helpers_1.decodeNodeContentBase64OrBytes)(deviceIdentityNode.content, 'missing prekeys device device-identity')
+            const bundle = oneTimeIdNode && oneTimeValueNode
+                ? {
+                    ...baseBundle,
+                    oneTimeKey: {
+                        id: (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(oneTimeIdNode.content, 'missing prekeys device key.id', constants_2.SIGNAL_KEY_ID_LENGTH), 'missing prekeys device key.id'),
+                        publicKey: (0, codec_1.decodeExactLength)(oneTimeValueNode.content, 'missing prekeys device key.value', constants_2.SIGNAL_KEY_DATA_LENGTH)
                     }
-                    : {})
-            };
-        });
+                }
+                : baseBundle;
+            let deviceIdentity;
+            if (deviceIdentityNode) {
+                deviceIdentity = (0, helpers_1.decodeNodeContentBase64OrBytes)(deviceIdentityNode.content, 'missing prekeys device device-identity');
+            }
+            bundles[index] = deviceIdentity
+                ? {
+                    deviceJid: deviceId === 0 ? userJid : `${user}:${deviceId}@${server}`,
+                    bundle,
+                    deviceIdentity
+                }
+                : {
+                    deviceJid: deviceId === 0 ? userJid : `${user}:${deviceId}@${server}`,
+                    bundle
+                };
+        }
+        return bundles;
     }
 }
 exports.SignalMissingPreKeysSyncApi = SignalMissingPreKeysSyncApi;

package/dist/signal/api/SignalRotateKeyApi.js

@@ -13,11 +13,13 @@ class SignalRotateKeyApi {
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS;
     }
     async rotateSignedPreKey(timeoutMs = this.defaultTimeoutMs) {
-        const registrationInfo = await this.signalStore.getRegistrationInfo();
+        const [registrationInfo, currentSignedPreKey] = await Promise.all([
+            this.signalStore.getRegistrationInfo(),
+            this.signalStore.getSignedPreKey()
+        ]);
         if (!registrationInfo) {
             throw new Error('signal rotate key requires registration info');
         }
-        const currentSignedPreKey = await this.signalStore.getSignedPreKey();
         const nextSignedPreKey = await (0, keygen_1.generateSignedPreKey)(currentSignedPreKey ? currentSignedPreKey.keyId + 1 : 1, registrationInfo.identityKeyPair.privKey);
         await this.signalStore.setSignedPreKey(nextSignedPreKey);
         this.logger.info('signal signed prekey uploading', {

package/dist/signal/api/SignalSessionSyncApi.js

@@ -2,9 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalSessionSyncApi = void 0;
 const constants_1 = require("../../protocol/constants");
+const jid_1 = require("../../protocol/jid");
 const codec_1 = require("../api/codec");
 const constants_2 = require("../api/constants");
+const result_map_1 = require("../api/result-map");
 const helpers_1 = require("../../transport/node/helpers");
+const query_1 = require("../../transport/node/query");
+function isKeyBundleResultPreferred(result) {
+    return 'bundle' in result;
+}
 class SignalSessionSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -43,7 +49,22 @@ class SignalSessionSyncApi {
                 reasonIdentity: (previous?.reasonIdentity ?? false) || target.reasonIdentity === true
             });
         }
-        const mergedTargets = [...targetByJid.values()];
+        const mergedTargets = new Array(targetByJid.size);
+        let mergedTargetsCount = 0;
+        for (const target of targetByJid.values()) {
+            mergedTargets[mergedTargetsCount] = target;
+            mergedTargetsCount += 1;
+        }
+        const userNodes = new Array(mergedTargets.length);
+        for (let index = 0; index < mergedTargets.length; index += 1) {
+            const target = mergedTargets[index];
+            userNodes[index] = {
+                tag: constants_1.WA_NODE_TAGS.USER,
+                attrs: target.reasonIdentity === true
+                    ? { jid: target.jid, reason: 'identity' }
+                    : { jid: target.jid }
+            };
+        }
         this.logger.debug('signal fetch key bundles request', {
             targets: mergedTargets.length,
             timeoutMs
@@ -59,34 +80,14 @@ class SignalSessionSyncApi {
                 {
                     tag: constants_1.WA_NODE_TAGS.KEY,
                     attrs: {},
-                    content: mergedTargets.map((target) => ({
-                        tag: constants_1.WA_NODE_TAGS.USER,
-                        attrs: {
-                            jid: target.jid,
-                            ...(target.reasonIdentity === true ? { reason: 'identity' } : {})
-                        }
-                    }))
+                    content: userNodes
                 }
             ]
         }, timeoutMs);
         return this.parseFetchKeyBundleResponse(responseNode, mergedTargets);
     }
     parseFetchKeyBundleResponse(node, requestedTargets) {
-        if (node.tag !== constants_1.WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid key bundle 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(`key bundle 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(`key bundle iq error (${code} ${text})`);
-        }
-        if (node.attrs.type !== constants_1.WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid key bundle response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        (0, query_1.assertIqResult)(node, 'key bundle');
         const listNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('key bundle response missing list node');
@@ -96,6 +97,7 @@ class SignalSessionSyncApi {
             throw new Error('key bundle response list is empty');
         }
         const parsedByJid = new Map();
+        const parsedByCanonicalJid = new Map();
         for (let index = 0; index < userNodes.length; index += 1) {
             const userNode = userNodes[index];
             const jid = userNode.attrs.jid;
@@ -104,30 +106,30 @@ class SignalSessionSyncApi {
             }
             const userErrorNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.ERROR);
             if (userErrorNode) {
-                parsedByJid.set(jid, {
+                (0, result_map_1.registerParsedResultByRawAndCanonicalKey)(parsedByJid, parsedByCanonicalJid, jid, (0, jid_1.canonicalizeSignalJid)(jid, this.hostDomain), {
                     jid,
                     errorCode: userErrorNode.attrs.code,
                     errorText: userErrorNode.attrs.text ?? 'unknown'
-                });
+                }, isKeyBundleResultPreferred);
                 continue;
             }
             const parsed = this.parseUserKeyBundle(userNode);
-            parsedByJid.set(jid, {
+            (0, result_map_1.registerParsedResultByRawAndCanonicalKey)(parsedByJid, parsedByCanonicalJid, jid, (0, jid_1.canonicalizeSignalJid)(jid, this.hostDomain), {
                 jid,
                 bundle: parsed.bundle,
                 ...(parsed.deviceIdentity ? { deviceIdentity: parsed.deviceIdentity } : {})
-            });
+            }, isKeyBundleResultPreferred);
         }
-        return requestedTargets.map((target) => {
-            const parsed = parsedByJid.get(target.jid);
-            if (parsed) {
-                return parsed;
-            }
-            return {
+        const output = new Array(requestedTargets.length);
+        for (let index = 0; index < requestedTargets.length; index += 1) {
+            const target = requestedTargets[index];
+            output[index] = parsedByJid.get(target.jid) ??
+                parsedByCanonicalJid.get((0, jid_1.canonicalizeSignalJid)(target.jid, this.hostDomain)) ?? {
                 jid: target.jid,
                 errorText: 'missing key bundle user in response'
             };
-        });
+        }
+        return output;
     }
     parseUserKeyBundle(node) {
         const registrationNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.REGISTRATION);

package/dist/signal/api/result-map.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerParsedResultByRawAndCanonicalKey = registerParsedResultByRawAndCanonicalKey;
+function mergePreferredParsedResult(target, key, next, isPreferred) {
+    const current = target.get(key);
+    if (!current || !isPreferred(current)) {
+        target.set(key, next);
+    }
+}
+function registerParsedResultByRawAndCanonicalKey(parsedByRawKey, parsedByCanonicalKey, rawKey, canonicalKey, result, isPreferred) {
+    mergePreferredParsedResult(parsedByRawKey, rawKey, result, isPreferred);
+    mergePreferredParsedResult(parsedByCanonicalKey, canonicalKey, result, isPreferred);
+}

package/dist/signal/constants.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SIGNAL_PREFIX = exports.WHISPER_GROUP_INFO = exports.CHAIN_KEY_LABEL = exports.MESSAGE_KEY_LABEL = exports.SENDER_KEY_FUTURE_MESSAGES_MAX = exports.FUTURE_MESSAGES_MAX = exports.MAX_UNUSED_KEYS = exports.MAX_PREV_SESSIONS = exports.SIGNATURE_SIZE = exports.SIGNAL_MAC_SIZE = exports.KEY_TYPE_CURVE25519 = exports.SERIALIZED_PUB_KEY_PREFIX = exports.SIGNAL_GROUP_VERSION = exports.SIGNAL_VERSION = void 0;
-const constants_1 = require("../crypto/core/constants");
+exports.SIGNAL_PREFIX = exports.WHISPER_GROUP_INFO = exports.CHAIN_KEY_LABEL = exports.MESSAGE_KEY_LABEL = exports.SENDER_KEY_FUTURE_MESSAGES_MAX = exports.FUTURE_MESSAGES_MAX = exports.MAX_UNUSED_KEYS = exports.MAX_PREV_SESSIONS = exports.SIGNAL_MAC_SIZE = exports.SIGNAL_GROUP_VERSION = exports.SIGNAL_VERSION = void 0;
 const bytes_1 = require("../util/bytes");
 exports.SIGNAL_VERSION = 3;
 exports.SIGNAL_GROUP_VERSION = 3;
-exports.SERIALIZED_PUB_KEY_PREFIX = constants_1.SERIALIZED_PUB_KEY_PREFIX;
-exports.KEY_TYPE_CURVE25519 = 5;
 exports.SIGNAL_MAC_SIZE = 8;
-exports.SIGNATURE_SIZE = 64;
 exports.MAX_PREV_SESSIONS = 40;
 exports.MAX_UNUSED_KEYS = 2000;
 exports.FUTURE_MESSAGES_MAX = 2000;

package/dist/signal/crypto/WaAdvSignature.js

@@ -25,17 +25,21 @@ async function verifySignalSignature(publicKey, message, signature) {
     if ((signature[63] & 0x60) !== 0) {
         return false;
     }
-    const signalSignature = new Uint8Array(signature);
-    const signBit = signalSignature[63] & 0x80;
-    signalSignature[63] &= 0x7f;
+    const signatureLastByteIndex = 63;
+    const originalSignatureLastByte = signature[signatureLastByteIndex];
+    const signBit = originalSignatureLastByte & 0x80;
+    signature[signatureLastByteIndex] = originalSignatureLastByte & 0x7f;
     const curvePublic = (0, _crypto_1.toRawPubKey)(publicKey);
     const edPublic = (0, X25519_1.montgomeryToEdwardsPublic)(curvePublic, signBit);
-    return (0, _crypto_1.ed25519VerifyRaw)(edPublic, signalSignature, message);
+    try {
+        return await _crypto_1.Ed25519.verify(message, signature, edPublic);
+    }
+    finally {
+        signature[signatureLastByteIndex] = originalSignatureLastByte;
+    }
 }
 async function signSignalMessage(privateKey, message) {
-    if (privateKey.length !== 32) {
-        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
-    }
+    (0, bytes_1.assertByteLength)(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
     const clampedPrivateKey = (0, X25519_1.clampCurvePrivateKeyInPlace)(privateKey);
     const privateScalar = (0, le_1.bytesToBigIntLE)(clampedPrivateKey);
     const encodedPublic = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(privateScalar));