zapo-js 0.1.1 → 0.2.0

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

@@ -1,19 +1,13 @@
-import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS } from '../../protocol/constants.js';
-import { splitJid } from '../../protocol/jid.js';
+import { WA_DEFAULTS, WA_NODE_TAGS } from '../../protocol/constants.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 { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
-import { parseIqError } from '../../transport/node/query.js';
-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;
+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) {
@@ -38,104 +32,129 @@ export class SignalMissingPreKeysSyncApi {
         return parsed;
     }
     parseFetchMissingPreKeysResponse(node, requestedTargets) {
-        if (node.tag !== WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid missing prekeys response tag: ${node.tag}`);
-        }
-        if (node.attrs.type === WA_IQ_TYPES.ERROR) {
-            const error = parseIqError(node);
-            throw new Error(`missing prekeys iq failed (${error.code}: ${error.text})`);
-        }
-        if (node.attrs.type !== WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid missing prekeys response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        assertIqResult(node, 'missing prekeys');
         const listNode = findNodeChild(node, WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('missing prekeys response missing list node');
         }
         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);
         }
-        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(toUserJid(target.userJid, {
+                    canonicalizeSignalServer: true
+                })) ?? {
                 userJid: target.userJid,
                 errorText: 'missing user in key_fetch response'
-            });
-        });
+            };
+        }
+        return results;
     }
     parseUserDevices(node, userJid) {
         const { user, server } = splitJid(userJid);
         const devices = getNodeChildrenByTag(node, WA_NODE_TAGS.DEVICE);
-        return devices.map((deviceNode, index) => {
-            const deviceId = parseDeviceId(deviceNode.attrs.id, `missing prekeys user[${userJid}] device[${index}].id`);
-            const registrationNode = findNodeChild(deviceNode, WA_NODE_TAGS.REGISTRATION);
-            const identityNode = findNodeChild(deviceNode, WA_NODE_TAGS.IDENTITY);
-            const signedKeyNode = findNodeChild(deviceNode, 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] = findNodeChildrenByTags(deviceNode, [
+                WA_NODE_TAGS.REGISTRATION,
+                WA_NODE_TAGS.IDENTITY,
+                WA_NODE_TAGS.SKEY,
+                WA_NODE_TAGS.KEY,
+                WA_NODE_TAGS.DEVICE_IDENTITY
+            ]);
             if (!registrationNode || !identityNode || !signedKeyNode) {
                 throw new Error(`missing prekeys device payload is incomplete for ${userJid}`);
             }
-            const signedKeyIdNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.ID);
-            const signedKeyValueNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.VALUE);
-            const signedKeySignatureNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.SIGNATURE);
+            const [signedKeyIdNode, signedKeyValueNode, signedKeySignatureNode] = findNodeChildrenByTags(signedKeyNode, [
+                WA_NODE_TAGS.ID,
+                WA_NODE_TAGS.VALUE,
+                WA_NODE_TAGS.SIGNATURE
+            ]);
             if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
                 throw new Error(`missing prekeys signed pre-key is incomplete for ${userJid}`);
             }
-            const oneTimeNode = findNodeChild(deviceNode, WA_NODE_TAGS.KEY);
-            const oneTimeIdNode = oneTimeNode
-                ? findNodeChild(oneTimeNode, WA_NODE_TAGS.ID)
-                : undefined;
-            const oneTimeValueNode = oneTimeNode
-                ? findNodeChild(oneTimeNode, WA_NODE_TAGS.VALUE)
-                : undefined;
+            let oneTimeIdNode;
+            let oneTimeValueNode;
+            if (oneTimeNode) {
+                const oneTimeNodes = findNodeChildrenByTags(oneTimeNode, [
+                    WA_NODE_TAGS.ID,
+                    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 = findNodeChild(deviceNode, WA_NODE_TAGS.DEVICE_IDENTITY);
-            const bundle = {
+            const baseBundle = {
                 regId: parseUint(decodeExactLength(registrationNode.content, 'missing prekeys device registration', SIGNAL_REGISTRATION_ID_LENGTH), 'missing prekeys device registration'),
                 identity: decodeExactLength(identityNode.content, 'missing prekeys device identity', SIGNAL_KEY_DATA_LENGTH),
                 signedKey: {
                     id: parseUint(decodeExactLength(signedKeyIdNode.content, 'missing prekeys device skey.id', SIGNAL_KEY_ID_LENGTH), 'missing prekeys device skey.id'),
                     publicKey: decodeExactLength(signedKeyValueNode.content, 'missing prekeys device skey.value', SIGNAL_KEY_DATA_LENGTH),
                     signature: decodeExactLength(signedKeySignatureNode.content, 'missing prekeys device skey.signature', SIGNAL_SIGNATURE_LENGTH)
-                },
-                ...(oneTimeIdNode && oneTimeValueNode
-                    ? {
-                        oneTimeKey: {
-                            id: parseUint(decodeExactLength(oneTimeIdNode.content, 'missing prekeys device key.id', SIGNAL_KEY_ID_LENGTH), 'missing prekeys device key.id'),
-                            publicKey: decodeExactLength(oneTimeValueNode.content, 'missing prekeys device key.value', SIGNAL_KEY_DATA_LENGTH)
-                        }
-                    }
-                    : {})
+                }
             };
-            return {
-                deviceJid: deviceId === 0 ? userJid : `${user}:${deviceId}@${server}`,
-                bundle,
-                ...(deviceIdentityNode
-                    ? {
-                        deviceIdentity: decodeNodeContentBase64OrBytes(deviceIdentityNode.content, 'missing prekeys device device-identity')
+            const bundle = oneTimeIdNode && oneTimeValueNode
+                ? {
+                    ...baseBundle,
+                    oneTimeKey: {
+                        id: parseUint(decodeExactLength(oneTimeIdNode.content, 'missing prekeys device key.id', SIGNAL_KEY_ID_LENGTH), 'missing prekeys device key.id'),
+                        publicKey: decodeExactLength(oneTimeValueNode.content, 'missing prekeys device key.value', SIGNAL_KEY_DATA_LENGTH)
                     }
-                    : {})
-            };
-        });
+                }
+                : baseBundle;
+            let deviceIdentity;
+            if (deviceIdentityNode) {
+                deviceIdentity = 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;
     }
 }

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,7 +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;
@@ -40,7 +46,22 @@ export 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: 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
@@ -56,34 +77,14 @@ export class SignalSessionSyncApi {
                 {
                     tag: WA_NODE_TAGS.KEY,
                     attrs: {},
-                    content: mergedTargets.map((target) => ({
-                        tag: 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 !== WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid key bundle 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(`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 !== WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid key bundle response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        assertIqResult(node, 'key bundle');
         const listNode = findNodeChild(node, WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('key bundle response missing list node');
@@ -93,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;
@@ -101,30 +103,30 @@ 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);
         }
-        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(canonicalizeSignalJid(target.jid, this.hostDomain)) ?? {
                 jid: target.jid,
                 errorText: 'missing key bundle user in response'
             };
-        });
+        }
+        return output;
     }
     parseUserKeyBundle(node) {
         const registrationNode = findNodeChild(node, WA_NODE_TAGS.REGISTRATION);

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,10 +1,10 @@
-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';
 import { modGroup } from '../../crypto/math/mod.js';
 import { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE, SIGNAL_PREFIX_SIGNATURE_RANDOM } from '../crypto/constants.js';
-import { concatBytes } from '../../util/bytes.js';
+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 (signature.length !== 64) {
@@ -13,17 +13,21 @@ export 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 = 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) {
-    if (privateKey.length !== 32) {
-        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
-    }
+    assertByteLength(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
     const clampedPrivateKey = clampCurvePrivateKeyInPlace(privateKey);
     const privateScalar = bytesToBigIntLE(clampedPrivateKey);
     const encodedPublic = encodeExtendedPoint(scalarMultBase(privateScalar));