zapo-js 0.1.0

package/dist/signal/api/SignalDigestSyncApi.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalDigestSyncApi = void 0;
+const _crypto_1 = require("../../crypto/index.js");
+const constants_1 = require("../../protocol/constants");
+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");
+const bytes_1 = require("../../util/bytes");
+class SignalDigestSyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.signalStore = options.signalStore;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? constants_1.WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
+        this.hostDomain = options.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
+    }
+    async validateLocalKeyBundle(timeoutMs = this.defaultTimeoutMs) {
+        this.logger.debug('signal digest query request', { timeoutMs });
+        const response = await this.query({
+            tag: constants_1.WA_NODE_TAGS.IQ,
+            attrs: {
+                type: constants_1.WA_IQ_TYPES.GET,
+                xmlns: constants_1.WA_XMLNS.SIGNAL,
+                to: this.hostDomain
+            },
+            content: [
+                {
+                    tag: constants_1.WA_NODE_TAGS.DIGEST,
+                    attrs: {}
+                }
+            ]
+        }, timeoutMs);
+        if (response.tag !== constants_1.WA_NODE_TAGS.IQ) {
+            throw new Error(`invalid signal digest response tag: ${response.tag}`);
+        }
+        if (response.attrs.type === constants_1.WA_IQ_TYPES.ERROR) {
+            const error = (0, query_1.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 !== constants_1.WA_IQ_TYPES.RESULT) {
+            throw new Error(`invalid signal digest response type: ${response.attrs.type ?? 'unknown'}`);
+        }
+        const digest = this.parseDigestPayload(response);
+        const expectedType = constants_2.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 (!(0, bytes_1.uint8Equal)(registrationInfo.identityKeyPair.pubKey, digest.identity)) {
+            return {
+                valid: false,
+                shouldReupload: true,
+                reason: 'identity_mismatch',
+                preKeyCount: digest.preKeyIds.length
+            };
+        }
+        if (signedPreKey.keyId !== digest.signedKey.id ||
+            !(0, bytes_1.uint8Equal)(signedPreKey.keyPair.pubKey, digest.signedKey.publicKey) ||
+            !(0, bytes_1.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 (0, _crypto_1.sha1)((0, bytes_1.concatBytes)(bytesToHash))).subarray(0, digest.hash.byteLength);
+        if (!(0, bytes_1.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 = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.DIGEST);
+        if (!digestNode) {
+            throw new Error('signal digest response missing digest node');
+        }
+        const registrationNode = (0, helpers_1.findNodeChild)(digestNode, constants_1.WA_NODE_TAGS.REGISTRATION);
+        const typeNode = (0, helpers_1.findNodeChild)(digestNode, constants_1.WA_NODE_TAGS.TYPE);
+        const identityNode = (0, helpers_1.findNodeChild)(digestNode, constants_1.WA_NODE_TAGS.IDENTITY);
+        const signedKeyNode = (0, helpers_1.findNodeChild)(digestNode, constants_1.WA_NODE_TAGS.SKEY);
+        const listNode = (0, helpers_1.findNodeChild)(digestNode, constants_1.WA_NODE_TAGS.LIST);
+        const hashNode = (0, helpers_1.findNodeChild)(digestNode, constants_1.WA_NODE_TAGS.HASH);
+        if (!registrationNode ||
+            !typeNode ||
+            !identityNode ||
+            !signedKeyNode ||
+            !listNode ||
+            !hashNode) {
+            throw new Error('signal digest response is incomplete');
+        }
+        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);
+        if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
+            throw new Error('signal digest response signed pre-key is incomplete');
+        }
+        const registrationId = (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(registrationNode.content, 'signal digest registration', constants_2.SIGNAL_REGISTRATION_ID_LENGTH), 'signal digest registration');
+        const keyBundleType = (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(typeNode.content, 'signal digest type', constants_2.SIGNAL_KEY_BUNDLE_TYPE_LENGTH), 'signal digest type');
+        const identity = (0, codec_1.decodeExactLength)(identityNode.content, 'signal digest identity', constants_2.SIGNAL_KEY_DATA_LENGTH);
+        const signedKeyId = (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(signedKeyIdNode.content, 'signal digest skey.id', constants_2.SIGNAL_KEY_ID_LENGTH), 'signal digest skey.id');
+        const signedKeyPublicKey = (0, codec_1.decodeExactLength)(signedKeyValueNode.content, 'signal digest skey.value', constants_2.SIGNAL_KEY_DATA_LENGTH);
+        const signedKeySignature = (0, codec_1.decodeExactLength)(signedKeySignatureNode.content, 'signal digest skey.signature', constants_2.SIGNAL_SIGNATURE_LENGTH);
+        const preKeyIds = (0, helpers_1.getNodeChildren)(listNode).map((child, index) => (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(child.content, `signal digest list[${index}]`, constants_2.SIGNAL_KEY_ID_LENGTH), `signal digest list[${index}]`));
+        const hash = (0, helpers_1.decodeNodeContentBase64OrBytes)(hashNode.content, 'signal digest hash');
+        return {
+            registrationId,
+            keyBundleType,
+            identity,
+            signedKey: {
+                id: signedKeyId,
+                publicKey: signedKeyPublicKey,
+                signature: signedKeySignature
+            },
+            preKeyIds,
+            hash
+        };
+    }
+}
+exports.SignalDigestSyncApi = SignalDigestSyncApi;

package/dist/signal/api/SignalIdentitySyncApi.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalIdentitySyncApi = void 0;
+const keys_1 = require("../../crypto/core/keys");
+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");
+class SignalIdentitySyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.signalStore = options.signalStore;
+        this.defaultTimeoutMs =
+            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)))];
+        if (normalizedTargets.length === 0) {
+            return [];
+        }
+        this.logger.debug('signal identity sync request', {
+            targets: normalizedTargets.length,
+            timeoutMs
+        });
+        const response = await this.query({
+            tag: constants_1.WA_NODE_TAGS.IQ,
+            attrs: {
+                type: constants_1.WA_IQ_TYPES.GET,
+                xmlns: constants_1.WA_XMLNS.SIGNAL,
+                to: this.hostDomain
+            },
+            content: [
+                {
+                    tag: constants_1.WA_NODE_TAGS.IDENTITY,
+                    attrs: {},
+                    content: normalizedTargets.map((jid) => ({
+                        tag: constants_1.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: (0, jid_1.parseSignalAddressFromJid)(entry.jid),
+                identityKey: (0, keys_1.toSerializedPubKey)(entry.identity)
+            })));
+        }
+        this.logger.debug('signal identity sync success', {
+            requested: normalizedTargets.length,
+            synced: entries.length
+        });
+        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'}`);
+        }
+        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) : '';
+            if (!jid || !requested.has(jid)) {
+                return [];
+            }
+            const errorNode = (0, helpers_1.findNodeChild)(userNode, constants_1.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 = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.IDENTITY);
+            if (!identityNode) {
+                throw new Error(`identity sync user missing identity node for ${jid}`);
+            }
+            const typeNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.TYPE);
+            const identity = (0, codec_1.decodeExactLength)(identityNode.content, 'identity sync identity', constants_2.SIGNAL_KEY_DATA_LENGTH);
+            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 [
+                {
+                    jid,
+                    identity,
+                    ...(parsedType !== undefined ? { type: parsedType } : {})
+                }
+            ];
+        });
+    }
+}
+exports.SignalIdentitySyncApi = SignalIdentitySyncApi;

package/dist/signal/api/SignalMissingPreKeysSyncApi.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalMissingPreKeysSyncApi = 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 prekeys_1 = require("../api/prekeys");
+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;
+}
+class SignalMissingPreKeysSyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? constants_1.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((0, prekeys_1.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 !== 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'}`);
+        }
+        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();
+        for (let index = 0; index < users.length; index += 1) {
+            const userNode = users[index];
+            const userJid = userNode.attrs.jid;
+            if (!userJid) {
+                continue;
+            }
+            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, {
+                    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 } = (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);
+            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);
+            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;
+            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 = {
+                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')
+                    }
+                    : {})
+            };
+        });
+    }
+}
+exports.SignalMissingPreKeysSyncApi = SignalMissingPreKeysSyncApi;

package/dist/signal/api/SignalRotateKeyApi.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalRotateKeyApi = void 0;
+const constants_1 = require("../../protocol/constants");
+const prekeys_1 = require("../api/prekeys");
+const keygen_1 = require("../registration/keygen");
+const query_1 = require("../../transport/node/query");
+class SignalRotateKeyApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.signalStore = options.signalStore;
+        this.defaultTimeoutMs = options.defaultTimeoutMs ?? constants_1.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 (0, keygen_1.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((0, prekeys_1.buildSignedPreKeyRotateIq)(nextSignedPreKey), timeoutMs);
+        if (response.tag !== constants_1.WA_NODE_TAGS.IQ) {
+            throw new Error(`invalid signal rotate response tag: ${response.tag}`);
+        }
+        if (response.attrs.type === constants_1.WA_IQ_TYPES.RESULT) {
+            this.logger.info('signal signed prekey upload completed', {
+                keyId: nextSignedPreKey.keyId
+            });
+            return { shouldDigestKey: false };
+        }
+        if (response.attrs.type !== constants_1.WA_IQ_TYPES.ERROR) {
+            throw new Error(`invalid signal rotate response type: ${response.attrs.type ?? 'unknown'}`);
+        }
+        const failure = (0, query_1.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 } : {}) };
+    }
+}
+exports.SignalRotateKeyApi = SignalRotateKeyApi;