zapo-js 0.1.0

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

@@ -0,0 +1,179 @@
+import { sha1 } from '../../crypto/index.js';
+import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
+import { decodeExactLength, parseUint } from '../api/codec.js';
+import { SIGNAL_KEY_BUNDLE_TYPE_BYTES, SIGNAL_KEY_BUNDLE_TYPE_LENGTH, SIGNAL_KEY_DATA_LENGTH, SIGNAL_KEY_ID_LENGTH, SIGNAL_REGISTRATION_ID_LENGTH, SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { parseIqError } from '../../transport/node/query.js';
+import { concatBytes, uint8Equal } from '../../util/bytes.js';
+export class SignalDigestSyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.signalStore = options.signalStore;
+        this.defaultTimeoutMs =
+            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 });
+        const response = await this.query({
+            tag: WA_NODE_TAGS.IQ,
+            attrs: {
+                type: WA_IQ_TYPES.GET,
+                xmlns: WA_XMLNS.SIGNAL,
+                to: this.hostDomain
+            },
+            content: [
+                {
+                    tag: WA_NODE_TAGS.DIGEST,
+                    attrs: {}
+                }
+            ]
+        }, timeoutMs);
+        if (response.tag !== WA_NODE_TAGS.IQ) {
+            throw new Error(`invalid signal digest response tag: ${response.tag}`);
+        }
+        if (response.attrs.type === WA_IQ_TYPES.ERROR) {
+            const error = parseIqError(response);
+            if (error.numericCode === 404 || error.code === '404') {
+                return {
+                    valid: false,
+                    shouldReupload: true,
+                    reason: 'missing_remote_digest',
+                    preKeyCount: 0
+                };
+            }
+            throw new Error(`signal digest iq failed (${error.code}: ${error.text})`);
+        }
+        if (response.attrs.type !== WA_IQ_TYPES.RESULT) {
+            throw new Error(`invalid signal digest response type: ${response.attrs.type ?? 'unknown'}`);
+        }
+        const digest = this.parseDigestPayload(response);
+        const expectedType = SIGNAL_KEY_BUNDLE_TYPE_BYTES[0];
+        if (digest.keyBundleType !== expectedType) {
+            return {
+                valid: false,
+                shouldReupload: false,
+                reason: 'unsupported_key_bundle_type',
+                preKeyCount: digest.preKeyIds.length
+            };
+        }
+        const [registrationInfo, signedPreKey] = await Promise.all([
+            this.signalStore.getRegistrationInfo(),
+            this.signalStore.getSignedPreKey()
+        ]);
+        if (!registrationInfo || !signedPreKey) {
+            return {
+                valid: false,
+                shouldReupload: false,
+                reason: 'missing_local_state',
+                preKeyCount: digest.preKeyIds.length
+            };
+        }
+        if (registrationInfo.registrationId !== digest.registrationId) {
+            return {
+                valid: false,
+                shouldReupload: true,
+                reason: 'registration_mismatch',
+                preKeyCount: digest.preKeyIds.length
+            };
+        }
+        if (!uint8Equal(registrationInfo.identityKeyPair.pubKey, digest.identity)) {
+            return {
+                valid: false,
+                shouldReupload: true,
+                reason: 'identity_mismatch',
+                preKeyCount: digest.preKeyIds.length
+            };
+        }
+        if (signedPreKey.keyId !== digest.signedKey.id ||
+            !uint8Equal(signedPreKey.keyPair.pubKey, digest.signedKey.publicKey) ||
+            !uint8Equal(signedPreKey.signature, digest.signedKey.signature)) {
+            return {
+                valid: false,
+                shouldReupload: true,
+                reason: 'signed_prekey_mismatch',
+                preKeyCount: digest.preKeyIds.length
+            };
+        }
+        const preKeys = await this.signalStore.getPreKeysById(digest.preKeyIds);
+        const bytesToHash = [
+            registrationInfo.identityKeyPair.pubKey,
+            signedPreKey.keyPair.pubKey,
+            signedPreKey.signature
+        ];
+        for (let index = 0; index < preKeys.length; index += 1) {
+            const preKey = preKeys[index];
+            if (!preKey) {
+                return {
+                    valid: false,
+                    shouldReupload: true,
+                    reason: 'missing_local_prekey',
+                    preKeyCount: digest.preKeyIds.length
+                };
+            }
+            bytesToHash.push(preKey.keyPair.pubKey);
+        }
+        const localHash = (await sha1(concatBytes(bytesToHash))).subarray(0, digest.hash.byteLength);
+        if (!uint8Equal(localHash, digest.hash)) {
+            return {
+                valid: false,
+                shouldReupload: true,
+                reason: 'hash_mismatch',
+                preKeyCount: digest.preKeyIds.length
+            };
+        }
+        return {
+            valid: true,
+            shouldReupload: false,
+            reason: 'ok',
+            preKeyCount: digest.preKeyIds.length
+        };
+    }
+    parseDigestPayload(node) {
+        const digestNode = findNodeChild(node, WA_NODE_TAGS.DIGEST);
+        if (!digestNode) {
+            throw new Error('signal digest response missing digest node');
+        }
+        const registrationNode = findNodeChild(digestNode, WA_NODE_TAGS.REGISTRATION);
+        const typeNode = findNodeChild(digestNode, WA_NODE_TAGS.TYPE);
+        const identityNode = findNodeChild(digestNode, WA_NODE_TAGS.IDENTITY);
+        const signedKeyNode = findNodeChild(digestNode, WA_NODE_TAGS.SKEY);
+        const listNode = findNodeChild(digestNode, WA_NODE_TAGS.LIST);
+        const hashNode = findNodeChild(digestNode, WA_NODE_TAGS.HASH);
+        if (!registrationNode ||
+            !typeNode ||
+            !identityNode ||
+            !signedKeyNode ||
+            !listNode ||
+            !hashNode) {
+            throw new Error('signal digest response is incomplete');
+        }
+        const signedKeyIdNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.ID);
+        const signedKeyValueNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.VALUE);
+        const signedKeySignatureNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.SIGNATURE);
+        if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
+            throw new Error('signal digest response signed pre-key is incomplete');
+        }
+        const registrationId = parseUint(decodeExactLength(registrationNode.content, 'signal digest registration', SIGNAL_REGISTRATION_ID_LENGTH), 'signal digest registration');
+        const keyBundleType = parseUint(decodeExactLength(typeNode.content, 'signal digest type', SIGNAL_KEY_BUNDLE_TYPE_LENGTH), 'signal digest type');
+        const identity = decodeExactLength(identityNode.content, 'signal digest identity', SIGNAL_KEY_DATA_LENGTH);
+        const signedKeyId = parseUint(decodeExactLength(signedKeyIdNode.content, 'signal digest skey.id', SIGNAL_KEY_ID_LENGTH), 'signal digest skey.id');
+        const signedKeyPublicKey = decodeExactLength(signedKeyValueNode.content, 'signal digest skey.value', SIGNAL_KEY_DATA_LENGTH);
+        const signedKeySignature = decodeExactLength(signedKeySignatureNode.content, 'signal digest skey.signature', SIGNAL_SIGNATURE_LENGTH);
+        const preKeyIds = getNodeChildren(listNode).map((child, index) => parseUint(decodeExactLength(child.content, `signal digest list[${index}]`, SIGNAL_KEY_ID_LENGTH), `signal digest list[${index}]`));
+        const hash = decodeNodeContentBase64OrBytes(hashNode.content, 'signal digest hash');
+        return {
+            registrationId,
+            keyBundleType,
+            identity,
+            signedKey: {
+                id: signedKeyId,
+                publicKey: signedKeyPublicKey,
+                signature: signedKeySignature
+            },
+            preKeyIds,
+            hash
+        };
+    }
+}

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

@@ -0,0 +1,111 @@
+import { toSerializedPubKey } from '../../crypto/core/keys.js';
+import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
+import { normalizeDeviceJid, 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';
+export class SignalIdentitySyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.signalStore = options.signalStore;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
+        this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
+    }
+    async syncIdentityKeys(targetJids, timeoutMs = this.defaultTimeoutMs) {
+        const normalizedTargets = [...new Set(targetJids.map((jid) => normalizeDeviceJid(jid)))];
+        if (normalizedTargets.length === 0) {
+            return [];
+        }
+        this.logger.debug('signal identity sync request', {
+            targets: normalizedTargets.length,
+            timeoutMs
+        });
+        const response = await this.query({
+            tag: WA_NODE_TAGS.IQ,
+            attrs: {
+                type: WA_IQ_TYPES.GET,
+                xmlns: WA_XMLNS.SIGNAL,
+                to: this.hostDomain
+            },
+            content: [
+                {
+                    tag: WA_NODE_TAGS.IDENTITY,
+                    attrs: {},
+                    content: normalizedTargets.map((jid) => ({
+                        tag: WA_NODE_TAGS.USER,
+                        attrs: { jid }
+                    }))
+                }
+            ]
+        }, timeoutMs);
+        const entries = this.parseIdentitySyncResponse(response, normalizedTargets);
+        const { signalStore } = this;
+        if (signalStore && entries.length > 0) {
+            await signalStore.setRemoteIdentities(entries.map((entry) => ({
+                address: parseSignalAddressFromJid(entry.jid),
+                identityKey: toSerializedPubKey(entry.identity)
+            })));
+        }
+        this.logger.debug('signal identity sync success', {
+            requested: normalizedTargets.length,
+            synced: entries.length
+        });
+        return entries;
+    }
+    parseIdentitySyncResponse(node, requestedJids) {
+        if (node.tag !== WA_NODE_TAGS.IQ) {
+            throw new Error(`invalid identity sync response tag: ${node.tag}`);
+        }
+        if (node.attrs.type === WA_IQ_TYPES.ERROR) {
+            const errorNode = findNodeChild(node, WA_NODE_TAGS.ERROR);
+            if (!errorNode) {
+                throw new Error(`identity sync iq error for ${node.attrs.id ?? 'unknown id'}`);
+            }
+            const code = errorNode.attrs.code ?? 'unknown';
+            const text = errorNode.attrs.text ?? errorNode.attrs.type ?? 'unknown';
+            throw new Error(`identity sync iq error (${code} ${text})`);
+        }
+        if (node.attrs.type !== WA_IQ_TYPES.RESULT) {
+            throw new Error(`invalid identity sync response type: ${node.attrs.type ?? 'unknown'}`);
+        }
+        const listNode = findNodeChild(node, WA_NODE_TAGS.LIST);
+        if (!listNode) {
+            throw new Error('identity sync response missing list node');
+        }
+        const requested = new Set(requestedJids);
+        const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
+        return userNodes.flatMap((userNode) => {
+            const jid = userNode.attrs.jid ? normalizeDeviceJid(userNode.attrs.jid) : '';
+            if (!jid || !requested.has(jid)) {
+                return [];
+            }
+            const errorNode = findNodeChild(userNode, WA_NODE_TAGS.ERROR);
+            if (errorNode) {
+                this.logger.warn('signal identity sync user error', {
+                    jid,
+                    code: errorNode.attrs.code,
+                    text: errorNode.attrs.text
+                });
+                return [];
+            }
+            const identityNode = findNodeChild(userNode, WA_NODE_TAGS.IDENTITY);
+            if (!identityNode) {
+                throw new Error(`identity sync user missing identity node for ${jid}`);
+            }
+            const typeNode = findNodeChild(userNode, WA_NODE_TAGS.TYPE);
+            const identity = decodeExactLength(identityNode.content, 'identity sync identity', SIGNAL_KEY_DATA_LENGTH);
+            const parsedType = typeNode
+                ? parseUint(decodeExactLength(typeNode.content, 'identity sync type', SIGNAL_KEY_BUNDLE_TYPE_LENGTH), 'identity sync type')
+                : undefined;
+            return [
+                {
+                    jid,
+                    identity,
+                    ...(parsedType !== undefined ? { type: parsedType } : {})
+                }
+            ];
+        });
+    }
+}

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

@@ -0,0 +1,141 @@
+import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS } from '../../protocol/constants.js';
+import { splitJid } 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;
+}
+export class SignalMissingPreKeysSyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
+    }
+    async fetchMissingPreKeys(targets, timeoutMs = this.defaultTimeoutMs) {
+        if (targets.length === 0) {
+            return [];
+        }
+        this.logger.debug('signal fetch missing prekeys request', {
+            users: targets.length,
+            timeoutMs
+        });
+        const response = await this.query(buildMissingPreKeysFetchIq(targets), timeoutMs);
+        const parsed = this.parseFetchMissingPreKeysResponse(response, targets);
+        this.logger.debug('signal fetch missing prekeys success', {
+            users: parsed.length
+        });
+        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'}`);
+        }
+        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();
+        for (let index = 0; index < users.length; index += 1) {
+            const userNode = users[index];
+            const userJid = userNode.attrs.jid;
+            if (!userJid) {
+                continue;
+            }
+            const userErrorNode = findNodeChild(userNode, WA_NODE_TAGS.ERROR);
+            if (userErrorNode) {
+                const parsedCode = Number.parseInt(userErrorNode.attrs.code ?? '', 10);
+                parsedByJid.set(userJid, {
+                    userJid,
+                    errorCode: Number.isSafeInteger(parsedCode) ? parsedCode : undefined,
+                    errorText: userErrorNode.attrs.text ?? userErrorNode.attrs.type ?? 'unknown'
+                });
+                continue;
+            }
+            parsedByJid.set(userJid, {
+                userJid,
+                devices: this.parseUserDevices(userNode, userJid)
+            });
+        }
+        return requestedTargets.map((target) => {
+            return (parsedByJid.get(target.userJid) ?? {
+                userJid: target.userJid,
+                errorText: 'missing user in key_fetch response'
+            });
+        });
+    }
+    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);
+            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);
+            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;
+            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 = {
+                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')
+                    }
+                    : {})
+            };
+        });
+    }
+}

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

@@ -0,0 +1,59 @@
+import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS } from '../../protocol/constants.js';
+import { buildSignedPreKeyRotateIq } from '../api/prekeys.js';
+import { generateSignedPreKey } from '../registration/keygen.js';
+import { parseIqError } from '../../transport/node/query.js';
+export class SignalRotateKeyApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.signalStore = options.signalStore;
+        this.defaultTimeoutMs = options.defaultTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS;
+    }
+    async rotateSignedPreKey(timeoutMs = this.defaultTimeoutMs) {
+        const registrationInfo = await this.signalStore.getRegistrationInfo();
+        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', {
+            keyId: nextSignedPreKey.keyId,
+            timeoutMs
+        });
+        const response = await this.query(buildSignedPreKeyRotateIq(nextSignedPreKey), timeoutMs);
+        if (response.tag !== WA_NODE_TAGS.IQ) {
+            throw new Error(`invalid signal rotate response tag: ${response.tag}`);
+        }
+        if (response.attrs.type === WA_IQ_TYPES.RESULT) {
+            this.logger.info('signal signed prekey upload completed', {
+                keyId: nextSignedPreKey.keyId
+            });
+            return { shouldDigestKey: false };
+        }
+        if (response.attrs.type !== WA_IQ_TYPES.ERROR) {
+            throw new Error(`invalid signal rotate response type: ${response.attrs.type ?? 'unknown'}`);
+        }
+        const failure = parseIqError(response);
+        const errorCode = failure.numericCode;
+        if (errorCode === 406) {
+            this.logger.warn('signal rotate key generated bad key');
+            return { shouldDigestKey: false, errorCode };
+        }
+        if (errorCode === 409) {
+            this.logger.warn('signal rotate key validation mismatch');
+            return { shouldDigestKey: true, errorCode };
+        }
+        if (errorCode !== undefined && errorCode >= 500) {
+            this.logger.warn('signal rotate key server error', {
+                errorCode
+            });
+            return { shouldDigestKey: false, errorCode };
+        }
+        this.logger.warn('signal rotate key unrecognized error', {
+            errorCode,
+            errorText: failure.text
+        });
+        return { shouldDigestKey: true, ...(errorCode !== undefined ? { errorCode } : {}) };
+    }
+}

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

@@ -0,0 +1,187 @@
+import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.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 { findNodeChild, getNodeChildrenByTag, decodeNodeContentBase64OrBytes } from '../../transport/node/helpers.js';
+export class SignalSessionSyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
+        this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
+    }
+    async fetchKeyBundle(target, timeoutMs = this.defaultTimeoutMs) {
+        const results = await this.fetchKeyBundles([target], timeoutMs);
+        const first = results[0];
+        if (!first || !('bundle' in first)) {
+            const errorCode = first && 'errorCode' in first ? (first.errorCode ?? 'unknown') : 'unknown';
+            const errorText = first && 'errorText' in first ? first.errorText : 'unknown';
+            throw new Error(`key bundle user error (${target.jid}): ${errorCode} ${errorText}`);
+        }
+        const parsed = first;
+        this.logger.debug('signal fetch key bundle success', {
+            requestJid: target.jid,
+            responseJid: parsed.jid,
+            hasOneTimeKey: parsed.bundle.oneTimeKey !== undefined,
+            hasDeviceIdentity: parsed.deviceIdentity !== undefined
+        });
+        return parsed;
+    }
+    async fetchKeyBundles(targets, timeoutMs = this.defaultTimeoutMs) {
+        if (targets.length === 0) {
+            return [];
+        }
+        const targetByJid = new Map();
+        for (let index = 0; index < targets.length; index += 1) {
+            const target = targets[index];
+            const previous = targetByJid.get(target.jid);
+            targetByJid.set(target.jid, {
+                jid: target.jid,
+                reasonIdentity: (previous?.reasonIdentity ?? false) || target.reasonIdentity === true
+            });
+        }
+        const mergedTargets = [...targetByJid.values()];
+        this.logger.debug('signal fetch key bundles request', {
+            targets: mergedTargets.length,
+            timeoutMs
+        });
+        const responseNode = await this.query({
+            tag: WA_NODE_TAGS.IQ,
+            attrs: {
+                type: WA_IQ_TYPES.GET,
+                xmlns: WA_XMLNS.SIGNAL,
+                to: this.hostDomain
+            },
+            content: [
+                {
+                    tag: WA_NODE_TAGS.KEY,
+                    attrs: {},
+                    content: mergedTargets.map((target) => ({
+                        tag: WA_NODE_TAGS.USER,
+                        attrs: {
+                            jid: target.jid,
+                            ...(target.reasonIdentity === true ? { reason: 'identity' } : {})
+                        }
+                    }))
+                }
+            ]
+        }, 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'}`);
+        }
+        const listNode = findNodeChild(node, WA_NODE_TAGS.LIST);
+        if (!listNode) {
+            throw new Error('key bundle response missing list node');
+        }
+        const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
+        if (userNodes.length === 0) {
+            throw new Error('key bundle response list is empty');
+        }
+        const parsedByJid = new Map();
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
+            const jid = userNode.attrs.jid;
+            if (!jid) {
+                continue;
+            }
+            const userErrorNode = findNodeChild(userNode, WA_NODE_TAGS.ERROR);
+            if (userErrorNode) {
+                parsedByJid.set(jid, {
+                    jid,
+                    errorCode: userErrorNode.attrs.code,
+                    errorText: userErrorNode.attrs.text ?? 'unknown'
+                });
+                continue;
+            }
+            const parsed = this.parseUserKeyBundle(userNode);
+            parsedByJid.set(jid, {
+                jid,
+                bundle: parsed.bundle,
+                ...(parsed.deviceIdentity ? { deviceIdentity: parsed.deviceIdentity } : {})
+            });
+        }
+        return requestedTargets.map((target) => {
+            const parsed = parsedByJid.get(target.jid);
+            if (parsed) {
+                return parsed;
+            }
+            return {
+                jid: target.jid,
+                errorText: 'missing key bundle user in response'
+            };
+        });
+    }
+    parseUserKeyBundle(node) {
+        const registrationNode = findNodeChild(node, WA_NODE_TAGS.REGISTRATION);
+        if (!registrationNode) {
+            throw new Error('key bundle user missing registration node');
+        }
+        const identityNode = findNodeChild(node, WA_NODE_TAGS.IDENTITY);
+        if (!identityNode) {
+            throw new Error('key bundle user missing identity node');
+        }
+        const signedPreKeyNode = findNodeChild(node, WA_NODE_TAGS.SKEY);
+        if (!signedPreKeyNode) {
+            throw new Error('key bundle user missing signed pre-key node');
+        }
+        const registrationBytes = decodeExactLength(registrationNode.content, 'key bundle registration', SIGNAL_REGISTRATION_ID_LENGTH);
+        const registrationId = parseUint(registrationBytes, 'key bundle registration');
+        const identity = decodeExactLength(identityNode.content, 'key bundle identity', SIGNAL_KEY_DATA_LENGTH);
+        const signedIdNode = findNodeChild(signedPreKeyNode, WA_NODE_TAGS.ID);
+        const signedValueNode = findNodeChild(signedPreKeyNode, WA_NODE_TAGS.VALUE);
+        const signedSignatureNode = findNodeChild(signedPreKeyNode, WA_NODE_TAGS.SIGNATURE);
+        if (!signedIdNode || !signedValueNode || !signedSignatureNode) {
+            throw new Error('key bundle signed pre-key is incomplete');
+        }
+        const signedIdBytes = decodeExactLength(signedIdNode.content, 'key bundle skey.id', SIGNAL_KEY_ID_LENGTH);
+        const signedValue = decodeExactLength(signedValueNode.content, 'key bundle skey.value', SIGNAL_KEY_DATA_LENGTH);
+        const signedSignature = decodeExactLength(signedSignatureNode.content, 'key bundle skey.signature', SIGNAL_SIGNATURE_LENGTH);
+        const preKeyNode = findNodeChild(node, WA_NODE_TAGS.KEY);
+        let oneTimeKey;
+        if (preKeyNode) {
+            const preKeyIdNode = findNodeChild(preKeyNode, WA_NODE_TAGS.ID);
+            const preKeyValueNode = findNodeChild(preKeyNode, WA_NODE_TAGS.VALUE);
+            if (!preKeyIdNode || !preKeyValueNode) {
+                throw new Error('key bundle one-time pre-key is incomplete');
+            }
+            const preKeyIdBytes = decodeExactLength(preKeyIdNode.content, 'key bundle key.id', SIGNAL_KEY_ID_LENGTH);
+            const preKeyValue = decodeExactLength(preKeyValueNode.content, 'key bundle key.value', SIGNAL_KEY_DATA_LENGTH);
+            oneTimeKey = {
+                id: parseUint(preKeyIdBytes, 'key bundle key.id'),
+                publicKey: preKeyValue
+            };
+        }
+        const deviceIdentityNode = findNodeChild(node, WA_NODE_TAGS.DEVICE_IDENTITY);
+        const deviceIdentity = deviceIdentityNode
+            ? decodeNodeContentBase64OrBytes(deviceIdentityNode.content, 'key bundle device-identity')
+            : undefined;
+        return {
+            bundle: {
+                regId: registrationId,
+                identity,
+                signedKey: {
+                    id: parseUint(signedIdBytes, 'key bundle skey.id'),
+                    publicKey: signedValue,
+                    signature: signedSignature
+                },
+                ...(oneTimeKey ? { oneTimeKey } : {})
+            },
+            ...(deviceIdentity ? { deviceIdentity } : {})
+        };
+    }
+}