zapo-js 0.1.2 → 0.2.0

package/dist/esm/retry/tracker.js

@@ -1,9 +1,33 @@
+import { isGroupOrBroadcastJid, normalizeDeviceJid } from '../protocol/jid.js';
+import { encodeRetryReplayPayload } from './codec.js';
 import { RETRY_OUTBOUND_TTL_MS } from './constants.js';
-import { encodeRetryReplayPayload } from './outbound.js';
 import { toError } from '../util/primitives.js';
 export function createOutboundRetryTracker(options) {
     const { retryStore, logger } = options;
     const retryTtlMs = retryStore.getTtlMs?.() ?? RETRY_OUTBOUND_TTL_MS;
+    const supportsRawReplayPayload = retryStore.supportsRawReplayPayload?.() ?? false;
+    const normalizeEligibleRequesterDeviceJids = (values) => {
+        if (!values || values.length === 0) {
+            return undefined;
+        }
+        const deduped = new Set();
+        for (let index = 0; index < values.length; index += 1) {
+            const raw = values[index]?.trim();
+            if (!raw) {
+                continue;
+            }
+            try {
+                deduped.add(normalizeDeviceJid(raw));
+            }
+            catch {
+                continue;
+            }
+        }
+        if (deduped.size === 0) {
+            return undefined;
+        }
+        return Array.from(deduped);
+    };
     const safeUpsertRetryOutboundRecord = async (record) => {
         try {
             await retryStore.upsertOutboundMessage(record);
@@ -22,34 +46,48 @@ export function createOutboundRetryTracker(options) {
     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 = encodeRetryReplayPayload(hint.replayPayload);
-            let hintedPersisted = false;
-            const createRetryOutboundRecord = (messageId, createdAtMs, updatedAtMs, expiresAtMs) => ({
+            const replayPayload = supportsRawReplayPayload
+                ? hint.replayPayload
+                : encodeRetryReplayPayload(hint.replayPayload);
+            let eligibleRequesterDeviceJids = normalizeEligibleRequesterDeviceJids(hint.eligibleRequesterDeviceJids);
+            if (!eligibleRequesterDeviceJids &&
+                resolvedToJid &&
+                !isGroupOrBroadcastJid(resolvedToJid)) {
+                try {
+                    eligibleRequesterDeviceJids = [normalizeDeviceJid(resolvedToJid)];
+                }
+                catch {
+                    eligibleRequesterDeviceJids = undefined;
+                }
+            }
+            const createRetryOutboundRecord = (messageId, updatedAtMs, expiresAtMs) => ({
                 messageId,
                 toJid: resolvedToJid,
                 participantJid: hint.participantJid,
                 recipientJid: hint.recipientJid,
+                eligibleRequesterDeviceJids,
+                deliveredRequesterDeviceJids: [],
                 messageType: hint.type,
                 replayMode,
                 replayPayload,
                 state: 'pending',
-                createdAtMs,
+                createdAtMs: nowMs,
                 updatedAtMs,
                 expiresAtMs
             });
-            if (hintedMessageId) {
-                hintedPersisted = await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(hintedMessageId, nowMs, nowMs, expiresAtMs));
-            }
             const result = await publish();
-            if (hintedPersisted && hintedMessageId && result.id === hintedMessageId) {
+            const persistedMessageId = result.id.trim();
+            if (!persistedMessageId) {
+                logger.warn('retry outbound record skipped: publish returned empty message id', {
+                    to: resolvedToJid,
+                    mode: replayMode
+                });
                 return result;
             }
             const persistedNowMs = Date.now();
-            await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(result.id, hintedMessageId ? nowMs : persistedNowMs, persistedNowMs, persistedNowMs + retryTtlMs));
+            await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(persistedMessageId, persistedNowMs, persistedNowMs + retryTtlMs));
             return result;
         }
     };

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

@@ -1,11 +1,13 @@
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { WA_DEFAULTS, WA_NODE_TAGS, WA_USYNC_CONTEXTS } from '../../protocol/constants.js';
-import { parseSignalAddressFromJid, splitJid } from '../../protocol/jid.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 } 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;
@@ -14,11 +16,15 @@ export class SignalDeviceSyncApi {
         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
@@ -123,16 +129,19 @@ export class SignalDeviceSyncApi {
     }
     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, sid) {
@@ -201,7 +210,8 @@ export class SignalDeviceSyncApi {
         }
         const requestedSet = new Set(requestedUsers);
         const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
-        const parsed = [];
+        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;
@@ -212,11 +222,13 @@ export class SignalDeviceSyncApi {
             if (!requestedSet.has(normalizedUserJid)) {
                 continue;
             }
-            parsed.push({
+            parsed[parsedCount] = {
                 jid: normalizedUserJid,
-                deviceJids: this.parseUserDeviceJids(userNode, normalizedUserJid)
-            });
+                deviceJids: this.parseUserDeviceJids(userNode, userJid, normalizedUserJid)
+            };
+            parsedCount += 1;
         }
+        parsed.length = parsedCount;
         return parsed;
     }
     parseLidSyncResponse(node, requestedUsers) {
@@ -231,7 +243,8 @@ export class SignalDeviceSyncApi {
         }
         const requestedSet = new Set(requestedUsers);
         const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
-        const parsed = [];
+        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;
@@ -250,7 +263,8 @@ export class SignalDeviceSyncApi {
             const lidNode = findNodeChild(userNode, WA_NODE_TAGS.LID);
             const contactNode = findNodeChild(userNode, WA_NODE_TAGS.CONTACT);
             if (!lidNode) {
-                parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null));
+                parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
+                parsedCount += 1;
                 continue;
             }
             const errorNode = findNodeChild(lidNode, WA_NODE_TAGS.ERROR);
@@ -260,12 +274,15 @@ export class SignalDeviceSyncApi {
                     code: errorNode.attrs.code,
                     text: errorNode.attrs.text
                 });
-                parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null));
+                parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
+                parsedCount += 1;
                 continue;
             }
             const lidJid = lidNode.attrs.val ? this.normalizeUserJid(lidNode.attrs.val) : null;
-            parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, lidJid));
+            parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, lidJid);
+            parsedCount += 1;
         }
+        parsed.length = parsedCount;
         return parsed;
     }
     buildLidSyncResult(jid, phoneJid, contactNode, lidJid) {
@@ -291,7 +308,7 @@ export class SignalDeviceSyncApi {
         }
         return contactNode.attrs.type === 'in';
     }
-    parseUserDeviceJids(userNode, userJid) {
+    parseUserDeviceJids(userNode, rawUserJid, normalizedUserJid) {
         const devicesNode = findNodeChild(userNode, WA_NODE_TAGS.DEVICES);
         if (!devicesNode) {
             return [];
@@ -299,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
             });
@@ -309,7 +326,8 @@ export class SignalDeviceSyncApi {
         if (!deviceListNode) {
             return [];
         }
-        const parsedUser = splitJid(userJid);
+        const parsedNormalizedUser = splitJid(normalizedUserJid);
+        const parsedRawUser = splitJid(rawUserJid);
         const dedup = new Set();
         for (const deviceNode of getNodeChildrenByTag(deviceListNode, 'device')) {
             const parsedId = deviceNode.attrs.id
@@ -318,16 +336,17 @@ export class SignalDeviceSyncApi {
             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);
+            const isHostedDevice = isHostedDeviceId(parsedId) || deviceNode.attrs.is_hosted === 'true';
+            dedup.add(buildDeviceJid(parsedNormalizedUser.user, parsedNormalizedUser.server, parsedId, {
+                rawServer: parsedRawUser.server,
+                isHosted: isHostedDevice
+            }));
         }
-        return deviceJids;
+        return Array.from(dedup);
     }
     normalizeUsers(userJids) {
-        const normalized = [];
+        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]);
@@ -335,18 +354,16 @@ export class SignalDeviceSyncApi {
                 continue;
             }
             dedup.add(normalizedJid);
-            normalized.push(normalizedJid);
+            normalized[normalizedCount] = normalizedJid;
+            normalizedCount += 1;
         }
+        normalized.length = normalizedCount;
         return normalized;
     }
     normalizeUserJid(jid) {
-        const address = parseSignalAddressFromJid(jid);
-        return `${address.user}@${address.server}`;
-    }
-    toDeviceJid(user, server, deviceId) {
-        if (deviceId === 0) {
-            return `${user}@${server}`;
-        }
-        return `${user}:${deviceId}@${server}`;
+        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,11 +165,11 @@ 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 = [];
         const listChildren = getNodeChildren(listNode);
+        const preKeyIds = new Array(listChildren.length);
         for (let index = 0; index < listChildren.length; index += 1) {
             const child = listChildren[index];
-            preKeyIds.push(parseUint(decodeExactLength(child.content, `signal digest list[${index}]`, SIGNAL_KEY_ID_LENGTH), `signal digest list[${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 {

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

@@ -1,12 +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;
@@ -14,17 +16,24 @@ 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 = [];
+    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 = normalizeDeviceJid(targetJids[index]);
+            const normalized = canonicalizeSignalJid(targetJids[index], this.hostDomain);
             if (dedup.has(normalized)) {
                 continue;
             }
             dedup.add(normalized);
-            normalizedTargets.push(normalized);
+            normalizedTargets[normalizedTargetsCount] = normalized;
+            normalizedTargetsCount += 1;
         }
+        normalizedTargets.length = normalizedTargetsCount;
         if (normalizedTargets.length === 0) {
             return [];
         }
@@ -83,10 +92,13 @@ export class SignalIdentitySyncApi {
         }
         const requested = new Set(requestedJids);
         const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
-        const parsed = [];
+        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 ? normalizeDeviceJid(userNode.attrs.jid) : '';
+            const jid = userNode.attrs.jid
+                ? canonicalizeSignalJid(userNode.attrs.jid, this.hostDomain)
+                : '';
             if (!jid || !requested.has(jid)) {
                 continue;
             }
@@ -109,18 +121,21 @@ export class SignalIdentitySyncApi {
                 ? parseUint(decodeExactLength(typeNode.content, 'identity sync type', SIGNAL_KEY_BUNDLE_TYPE_LENGTH), 'identity sync type')
                 : undefined;
             if (parsedType === undefined) {
-                parsed.push({
+                parsed[parsedCount] = {
                     jid,
                     identity
-                });
+                };
+                parsedCount += 1;
                 continue;
             }
-            parsed.push({
+            parsed[parsedCount] = {
                 jid,
                 identity,
                 type: parsedType
-            });
+            };
+            parsedCount += 1;
         }
+        parsed.length = parsedCount;
         return parsed;
     }
 }

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

@@ -1,10 +1,14 @@
 import { WA_DEFAULTS, WA_NODE_TAGS } from '../../protocol/constants.js';
-import { splitJid } from '../../protocol/jid.js';
+import { splitJid, toUserJid } from '../../protocol/jid.js';
 import { decodeExactLength, parseUint } from '../api/codec.js';
 import { SIGNAL_KEY_DATA_LENGTH, SIGNAL_KEY_ID_LENGTH, SIGNAL_REGISTRATION_ID_LENGTH, SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
 import { buildMissingPreKeysFetchIq } from '../api/prekeys.js';
+import { registerParsedResultByRawAndCanonicalKey } from '../api/result-map.js';
 import { decodeNodeContentBase64OrBytes, findNodeChildrenByTags, findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
 import { assertIqResult } from '../../transport/node/query.js';
+function isMissingPreKeysUserResultPreferred(result) {
+    return 'devices' in result;
+}
 export class SignalMissingPreKeysSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -35,31 +39,38 @@ export class SignalMissingPreKeysSyncApi {
         }
         const users = getNodeChildrenByTag(listNode, 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 = toUserJid(userJid, {
+                canonicalizeSignalServer: true
+            });
             const userErrorNode = findNodeChild(userNode, WA_NODE_TAGS.ERROR);
             if (userErrorNode) {
                 const parsedCode = Number.parseInt(userErrorNode.attrs.code ?? '', 10);
-                parsedByJid.set(userJid, {
+                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, {
+            registerParsedResultByRawAndCanonicalKey(parsedByJid, parsedByCanonicalJid, userJid, canonicalUserJid, {
                 userJid,
-                devices: this.parseUserDevices(userNode, userJid)
-            });
+                devices: this.parseUserDevices(userNode, canonicalUserJid)
+            }, isMissingPreKeysUserResultPreferred);
         }
         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) ?? {
+            results[index] = parsedByJid.get(target.userJid) ??
+                parsedByCanonicalJid.get(toUserJid(target.userJid, {
+                    canonicalizeSignalServer: true
+                })) ?? {
                 userJid: target.userJid,
                 errorText: 'missing user in key_fetch response'
             };

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

@@ -10,11 +10,13 @@ export class SignalRotateKeyApi {
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? 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 generateSignedPreKey(currentSignedPreKey ? currentSignedPreKey.keyId + 1 : 1, registrationInfo.identityKeyPair.privKey);
         await this.signalStore.setSignedPreKey(nextSignedPreKey);
         this.logger.info('signal signed prekey uploading', {

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

@@ -1,8 +1,13 @@
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
+import { canonicalizeSignalJid } from '../../protocol/jid.js';
 import { decodeExactLength, parseUint } from '../api/codec.js';
 import { SIGNAL_KEY_DATA_LENGTH, SIGNAL_KEY_ID_LENGTH, SIGNAL_REGISTRATION_ID_LENGTH, SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
+import { registerParsedResultByRawAndCanonicalKey } from '../api/result-map.js';
 import { findNodeChild, getNodeChildrenByTag, decodeNodeContentBase64OrBytes } from '../../transport/node/helpers.js';
 import { assertIqResult } from '../../transport/node/query.js';
+function isKeyBundleResultPreferred(result) {
+    return 'bundle' in result;
+}
 export class SignalSessionSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -41,9 +46,11 @@ export class SignalSessionSyncApi {
                 reasonIdentity: (previous?.reasonIdentity ?? false) || target.reasonIdentity === true
             });
         }
-        const mergedTargets = [];
+        const mergedTargets = new Array(targetByJid.size);
+        let mergedTargetsCount = 0;
         for (const target of targetByJid.values()) {
-            mergedTargets.push(target);
+            mergedTargets[mergedTargetsCount] = target;
+            mergedTargetsCount += 1;
         }
         const userNodes = new Array(mergedTargets.length);
         for (let index = 0; index < mergedTargets.length; index += 1) {
@@ -87,6 +94,7 @@ export 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;
@@ -95,24 +103,25 @@ export class SignalSessionSyncApi {
             }
             const userErrorNode = findNodeChild(userNode, WA_NODE_TAGS.ERROR);
             if (userErrorNode) {
-                parsedByJid.set(jid, {
+                registerParsedResultByRawAndCanonicalKey(parsedByJid, parsedByCanonicalJid, jid, canonicalizeSignalJid(jid, this.hostDomain), {
                     jid,
                     errorCode: userErrorNode.attrs.code,
                     errorText: userErrorNode.attrs.text ?? 'unknown'
-                });
+                }, isKeyBundleResultPreferred);
                 continue;
             }
             const parsed = this.parseUserKeyBundle(userNode);
-            parsedByJid.set(jid, {
+            registerParsedResultByRawAndCanonicalKey(parsedByJid, parsedByCanonicalJid, jid, canonicalizeSignalJid(jid, this.hostDomain), {
                 jid,
                 bundle: parsed.bundle,
                 ...(parsed.deviceIdentity ? { deviceIdentity: parsed.deviceIdentity } : {})
-            });
+            }, isKeyBundleResultPreferred);
         }
         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) ?? {
+            output[index] = parsedByJid.get(target.jid) ??
+                parsedByCanonicalJid.get(canonicalizeSignalJid(target.jid, this.hostDomain)) ?? {
                 jid: target.jid,
                 errorText: 'missing key bundle user in response'
             };

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

@@ -0,0 +1,10 @@
+function mergePreferredParsedResult(target, key, next, isPreferred) {
+    const current = target.get(key);
+    if (!current || !isPreferred(current)) {
+        target.set(key, next);
+    }
+}
+export function registerParsedResultByRawAndCanonicalKey(parsedByRawKey, parsedByCanonicalKey, rawKey, canonicalKey, result, isPreferred) {
+    mergePreferredParsedResult(parsedByRawKey, rawKey, result, isPreferred);
+    mergePreferredParsedResult(parsedByCanonicalKey, canonicalKey, result, isPreferred);
+}

package/dist/esm/signal/constants.js

@@ -1,11 +1,7 @@
-import { SERIALIZED_PUB_KEY_PREFIX as CORE_SERIALIZED_PUB_KEY_PREFIX } from '../crypto/core/constants.js';
 import { TEXT_ENCODER } from '../util/bytes.js';
 export const SIGNAL_VERSION = 3;
 export const SIGNAL_GROUP_VERSION = 3;
-export const SERIALIZED_PUB_KEY_PREFIX = CORE_SERIALIZED_PUB_KEY_PREFIX;
-export const KEY_TYPE_CURVE25519 = 5;
 export const SIGNAL_MAC_SIZE = 8;
-export const SIGNATURE_SIZE = 64;
 export const MAX_PREV_SESSIONS = 40;
 export const MAX_UNUSED_KEYS = 2000;
 export const FUTURE_MESSAGES_MAX = 2000;

package/dist/esm/signal/crypto/WaAdvSignature.js

@@ -1,4 +1,4 @@
-import { ed25519VerifyRaw, importHmacKey, hmacSign, randomBytesAsync, sha512, toRawPubKey } from '../../crypto/index.js';
+import { Ed25519, importHmacKey, hmacSign, randomBytesAsync, sha512, toRawPubKey } from '../../crypto/index.js';
 import { clampCurvePrivateKeyInPlace, montgomeryToEdwardsPublic } from '../../crypto/curves/X25519.js';
 import { encodeExtendedPoint, scalarMultBase } from '../../crypto/math/edwards.js';
 import { bytesToBigIntLE, bigIntToBytesLE } from '../../crypto/math/le.js';
@@ -7,18 +7,24 @@ import { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_H
 import { assertByteLength, concatBytes } from '../../util/bytes.js';
 export { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE } from '../crypto/constants.js';
 export async function verifySignalSignature(publicKey, message, signature) {
-    if (!assertByteLength(signature, 64, 'invalid signal signature length', false)) {
+    if (signature.length !== 64) {
         return false;
     }
     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 = toRawPubKey(publicKey);
     const edPublic = montgomeryToEdwardsPublic(curvePublic, signBit);
-    return ed25519VerifyRaw(edPublic, signalSignature, message);
+    try {
+        return await Ed25519.verify(message, signature, edPublic);
+    }
+    finally {
+        signature[signatureLastByteIndex] = originalSignatureLastByte;
+    }
 }
 export async function signSignalMessage(privateKey, message) {
     assertByteLength(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);