zapo-js 0.2.0 → 1.0.0

package/dist/signal/encoding.js

@@ -1,21 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toSignalAddressParts = toSignalAddressParts;
-exports.decodeSignalAddressFromRow = decodeSignalAddressFromRow;
-exports.decodeSignalRegistrationRow = decodeSignalRegistrationRow;
-exports.decodeSignalPreKeyRow = decodeSignalPreKeyRow;
-exports.decodeSignalSignedPreKeyRow = decodeSignalSignedPreKeyRow;
-exports.encodeSignalSessionRecord = encodeSignalSessionRecord;
-exports.decodeSignalSessionRecord = decodeSignalSessionRecord;
-exports.encodeSenderKeyRecord = encodeSenderKeyRecord;
-exports.decodeSenderKeyRecord = decodeSenderKeyRecord;
-exports.decodeSenderKeyDistributionRow = decodeSenderKeyDistributionRow;
 exports.decodeStoreCount = decodeStoreCount;
-exports.decodeSignalRemoteIdentity = decodeSignalRemoteIdentity;
-const _proto_1 = require("../proto.js");
 const constants_1 = require("../protocol/constants");
-const bytes_1 = require("../util/bytes");
 const coercion_1 = require("../util/coercion");
+/** Flattens a {@link SignalAddress} into plain fields, defaulting `server` to the host domain. */
 function toSignalAddressParts(address) {
     return {
         user: address.user,
@@ -23,335 +12,10 @@ function toSignalAddressParts(address) {
         device: address.device
     };
 }
-function decodeSignalAddressFromRow(row) {
-    return {
-        user: (0, coercion_1.asString)(row.sender_user, 'signal.sender_user'),
-        server: (0, coercion_1.asString)(row.sender_server, 'signal.sender_server'),
-        device: (0, coercion_1.asNumber)(row.sender_device, 'signal.sender_device')
-    };
-}
-function decodeSignalRegistrationRow(row) {
-    return {
-        registrationId: (0, coercion_1.asNumber)(row.registration_id, 'signal_registration.registration_id'),
-        identityKeyPair: {
-            pubKey: (0, coercion_1.asBytes)(row.identity_pub_key, 'signal_registration.identity_pub_key'),
-            privKey: (0, coercion_1.asBytes)(row.identity_priv_key, 'signal_registration.identity_priv_key')
-        }
-    };
-}
-function decodeSignalPreKeyRow(row) {
-    return {
-        keyId: (0, coercion_1.asNumber)(row.key_id, 'signal_prekey.key_id'),
-        keyPair: {
-            pubKey: (0, coercion_1.asBytes)(row.pub_key, 'signal_prekey.pub_key'),
-            privKey: (0, coercion_1.asBytes)(row.priv_key, 'signal_prekey.priv_key')
-        },
-        uploaded: (0, coercion_1.toBoolOrUndef)(row.uploaded)
-    };
-}
-function decodeSignalSignedPreKeyRow(row) {
-    return {
-        keyId: (0, coercion_1.asNumber)(row.key_id, 'signal_signed_prekey.key_id'),
-        keyPair: {
-            pubKey: (0, coercion_1.asBytes)(row.pub_key, 'signal_signed_prekey.pub_key'),
-            privKey: (0, coercion_1.asBytes)(row.priv_key, 'signal_signed_prekey.priv_key')
-        },
-        signature: (0, coercion_1.asBytes)(row.signature, 'signal_signed_prekey.signature'),
-        uploaded: (0, coercion_1.toBoolOrUndef)(row.uploaded)
-    };
-}
-function encodeSignalSessionSnapshot(session) {
-    return {
-        sessionVersion: 3,
-        localRegistrationId: session.local.regId,
-        localIdentityPublic: session.local.pubKey,
-        remoteRegistrationId: session.remote.regId,
-        remoteIdentityPublic: session.remote.pubKey,
-        rootKey: session.rootKey,
-        previousCounter: session.prevSendChainHighestIndex,
-        senderChain: encodeSignalSendChain(session.sendChain),
-        receiverChains: (() => {
-            const src = session.recvChains;
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = encodeSignalRecvChain(src[i]);
-            return arr;
-        })(),
-        pendingPreKey: session.initialExchangeInfo
-            ? {
-                preKeyId: session.initialExchangeInfo.remoteOneTimeId ?? undefined,
-                signedPreKeyId: session.initialExchangeInfo.remoteSignedId,
-                baseKey: session.initialExchangeInfo.localOneTimePubKey
-            }
-            : undefined,
-        aliceBaseKey: session.aliceBaseKey ?? undefined
-    };
-}
-function encodeSignalSendChain(chain) {
-    return {
-        senderRatchetKey: chain.ratchetKey.pubKey,
-        senderRatchetKeyPrivate: chain.ratchetKey.privKey,
-        chainKey: {
-            index: chain.nextMsgIndex,
-            key: chain.chainKey
-        },
-        messageKeys: []
-    };
-}
-function encodeSignalRecvChain(chain) {
-    return {
-        senderRatchetKey: chain.ratchetPubKey,
-        chainKey: {
-            index: chain.nextMsgIndex,
-            key: chain.chainKey
-        },
-        messageKeys: (() => {
-            const src = chain.unusedMsgKeys ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1) {
-                const messageKey = src[i];
-                arr[i] = {
-                    index: messageKey.index,
-                    cipherKey: messageKey.cipherKey,
-                    macKey: messageKey.macKey,
-                    iv: messageKey.iv
-                };
-            }
-            return arr;
-        })()
-    };
-}
-function decodeSignalMessageKey(messageKey, field) {
-    const cipherKey = (0, coercion_1.asBytes)(messageKey.cipherKey, `${field}.cipherKey`);
-    (0, bytes_1.assertByteLength)(cipherKey, 32, `invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
-    const macKey = (0, coercion_1.asBytes)(messageKey.macKey, `${field}.macKey`);
-    (0, bytes_1.assertByteLength)(macKey, 32, `invalid ${field}.macKey length ${macKey.byteLength}`);
-    const iv = (0, coercion_1.asBytes)(messageKey.iv, `${field}.iv`);
-    (0, bytes_1.assertByteLength)(iv, 16, `invalid ${field}.iv length ${iv.byteLength}`);
-    return {
-        index: (0, coercion_1.asNumber)(messageKey.index, `${field}.index`),
-        cipherKey,
-        macKey,
-        iv
-    };
-}
-function decodeSignalRecvChain(chain, field) {
-    const chainKey = chain.chainKey;
-    if (!chainKey) {
-        throw new Error(`missing ${field}.chainKey`);
-    }
-    const ratchetPubKey = (0, coercion_1.asBytes)(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    (0, bytes_1.assertByteLength)(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    const chainKeyBytes = (0, coercion_1.asBytes)(chainKey.key, `${field}.chainKey.key`);
-    (0, bytes_1.assertByteLength)(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    return {
-        ratchetPubKey,
-        nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
-        chainKey: chainKeyBytes,
-        unusedMsgKeys: (() => {
-            const src = chain.messageKeys ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = decodeSignalMessageKey(src[i], `${field}.messageKeys[${i}]`);
-            return arr;
-        })()
-    };
-}
-function decodeSignalSendChain(chain, field) {
-    const chainKey = chain.chainKey;
-    if (!chainKey) {
-        throw new Error(`missing ${field}.chainKey`);
-    }
-    const privateKey = (0, coercion_1.asOptionalBytes)(chain.senderRatchetKeyPrivate, `${field}.senderRatchetKeyPrivate`);
-    if (!privateKey) {
-        throw new Error(`missing ${field}.senderRatchetKeyPrivate`);
-    }
-    (0, bytes_1.assertByteLength)(privateKey, 32, `invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
-    const ratchetPubKey = (0, coercion_1.asBytes)(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    (0, bytes_1.assertByteLength)(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    const chainKeyBytes = (0, coercion_1.asBytes)(chainKey.key, `${field}.chainKey.key`);
-    (0, bytes_1.assertByteLength)(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    return {
-        ratchetKey: {
-            pubKey: ratchetPubKey,
-            privKey: privateKey
-        },
-        nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
-        chainKey: chainKeyBytes
-    };
-}
-function decodeSignalSessionSnapshot(session, field) {
-    const senderChain = session.senderChain;
-    if (!senderChain) {
-        throw new Error(`missing ${field}.senderChain`);
-    }
-    const pendingPreKey = session.pendingPreKey;
-    const localPubKey = (0, coercion_1.asBytes)(session.localIdentityPublic, `${field}.localIdentityPublic`);
-    (0, bytes_1.assertByteLength)(localPubKey, 33, `invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
-    const remotePubKey = (0, coercion_1.asBytes)(session.remoteIdentityPublic, `${field}.remoteIdentityPublic`);
-    (0, bytes_1.assertByteLength)(remotePubKey, 33, `invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
-    const rootKey = (0, coercion_1.asBytes)(session.rootKey, `${field}.rootKey`);
-    (0, bytes_1.assertByteLength)(rootKey, 32, `invalid ${field}.rootKey length ${rootKey.byteLength}`);
-    const localOneTimePubKey = pendingPreKey
-        ? (0, coercion_1.asBytes)(pendingPreKey.baseKey, `${field}.pendingPreKey.baseKey`)
-        : null;
-    if (localOneTimePubKey) {
-        (0, bytes_1.assertByteLength)(localOneTimePubKey, 33, `invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
-    }
-    const aliceBaseKey = (0, coercion_1.asOptionalBytes)(session.aliceBaseKey, `${field}.aliceBaseKey`) ?? null;
-    if (aliceBaseKey) {
-        (0, bytes_1.assertByteLength)(aliceBaseKey, 33, `invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
-    }
-    return {
-        local: {
-            regId: (0, coercion_1.asNumber)(session.localRegistrationId, `${field}.localRegistrationId`),
-            pubKey: localPubKey
-        },
-        remote: {
-            regId: (0, coercion_1.asNumber)(session.remoteRegistrationId, `${field}.remoteRegistrationId`),
-            pubKey: remotePubKey
-        },
-        rootKey,
-        sendChain: decodeSignalSendChain(senderChain, `${field}.senderChain`),
-        recvChains: (() => {
-            const src = session.receiverChains ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = decodeSignalRecvChain(src[i], `${field}.receiverChains[${i}]`);
-            return arr;
-        })(),
-        initialExchangeInfo: pendingPreKey
-            ? {
-                remoteOneTimeId: (0, coercion_1.asOptionalNumber)(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
-                    null,
-                remoteSignedId: (0, coercion_1.asNumber)(pendingPreKey.signedPreKeyId, `${field}.pendingPreKey.signedPreKeyId`),
-                localOneTimePubKey: localOneTimePubKey
-            }
-            : null,
-        prevSendChainHighestIndex: (0, coercion_1.asOptionalNumber)(session.previousCounter, `${field}.previousCounter`) ?? 0,
-        aliceBaseKey
-    };
-}
-function encodeSignalSessionRecord(record) {
-    return _proto_1.proto.RecordStructure.encode({
-        currentSession: encodeSignalSessionSnapshot(record),
-        previousSessions: (() => {
-            const src = record.prevSessions;
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = encodeSignalSessionSnapshot(src[i]);
-            return arr;
-        })()
-    }).finish();
-}
-function decodeSignalSessionRecord(raw) {
-    const decoded = _proto_1.proto.RecordStructure.decode((0, coercion_1.asBytes)(raw, 'signal_sessions.record'));
-    if (!decoded.currentSession) {
-        throw new Error('missing signal_sessions.record.currentSession');
-    }
-    const current = decodeSignalSessionSnapshot(decoded.currentSession, 'signal_sessions.currentSession');
-    return {
-        ...current,
-        prevSessions: (() => {
-            const src = decoded.previousSessions ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = decodeSignalSessionSnapshot(src[i], `signal_sessions.previousSessions[${i}]`);
-            return arr;
-        })()
-    };
-}
-function encodeSenderKeyRecord(record) {
-    return _proto_1.proto.SenderKeyRecordStructure.encode({
-        senderKeyStates: [
-            {
-                senderKeyId: record.keyId,
-                senderChainKey: {
-                    iteration: record.iteration,
-                    seed: record.chainKey
-                },
-                senderSigningKey: {
-                    public: record.signingPublicKey,
-                    private: record.signingPrivateKey
-                },
-                senderMessageKeys: (() => {
-                    const src = record.unusedMessageKeys ?? [];
-                    const arr = new Array(src.length);
-                    for (let i = 0; i < src.length; i += 1) {
-                        const messageKey = src[i];
-                        arr[i] = {
-                            iteration: messageKey.iteration,
-                            seed: messageKey.seed
-                        };
-                    }
-                    return arr;
-                })()
-            }
-        ]
-    }).finish();
-}
-function decodeSenderKeyState(state, field) {
-    if (!state.senderChainKey) {
-        throw new Error(`missing ${field}.senderChainKey`);
-    }
-    if (!state.senderSigningKey) {
-        throw new Error(`missing ${field}.senderSigningKey`);
-    }
-    return {
-        keyId: (0, coercion_1.asNumber)(state.senderKeyId, `${field}.senderKeyId`),
-        iteration: (0, coercion_1.asNumber)(state.senderChainKey.iteration, `${field}.senderChainKey.iteration`),
-        chainKey: (0, coercion_1.asBytes)(state.senderChainKey.seed, `${field}.senderChainKey.seed`),
-        signingPublicKey: (0, coercion_1.asBytes)(state.senderSigningKey.public, `${field}.senderSigningKey.public`),
-        signingPrivateKey: state.senderSigningKey.private !== null && state.senderSigningKey.private !== undefined
-            ? (0, coercion_1.asBytes)(state.senderSigningKey.private, `${field}.senderSigningKey.private`)
-            : undefined,
-        unusedMessageKeys: (() => {
-            const src = state.senderMessageKeys ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1) {
-                const messageKey = src[i];
-                arr[i] = {
-                    iteration: (0, coercion_1.asNumber)(messageKey.iteration, `${field}.senderMessageKeys[${i}].iteration`),
-                    seed: (0, coercion_1.asBytes)(messageKey.seed, `${field}.senderMessageKeys[${i}].seed`)
-                };
-            }
-            return arr;
-        })()
-    };
-}
-function decodeSenderKeyRecord(raw, groupId, sender) {
-    const decoded = _proto_1.proto.SenderKeyRecordStructure.decode((0, coercion_1.asBytes)(raw, 'sender_keys.record'));
-    const state = decoded.senderKeyStates?.[0];
-    if (!state) {
-        throw new Error('missing sender_keys.record.senderKeyStates[0]');
-    }
-    const parsed = decodeSenderKeyState(state, 'sender_keys.record.senderKeyStates[0]');
-    return {
-        groupId,
-        sender,
-        keyId: parsed.keyId,
-        iteration: parsed.iteration,
-        chainKey: parsed.chainKey,
-        signingPublicKey: parsed.signingPublicKey,
-        signingPrivateKey: parsed.signingPrivateKey,
-        unusedMessageKeys: parsed.unusedMessageKeys
-    };
-}
-function decodeSenderKeyDistributionRow(row) {
-    return {
-        groupId: (0, coercion_1.asString)(row.group_id, 'sender_key_distribution.group_id'),
-        sender: {
-            user: (0, coercion_1.asString)(row.sender_user, 'sender_key_distribution.sender_user'),
-            server: (0, coercion_1.asString)(row.sender_server, 'sender_key_distribution.sender_server'),
-            device: (0, coercion_1.asNumber)(row.sender_device, 'sender_key_distribution.sender_device')
-        },
-        keyId: (0, coercion_1.asNumber)(row.key_id, 'sender_key_distribution.key_id'),
-        timestampMs: (0, coercion_1.asNumber)(row.timestamp_ms, 'sender_key_distribution.timestamp_ms')
-    };
-}
+/**
+ * Reads the `count` field of a single-row SQL `COUNT(*)` result, returning
+ * `0` when the row is missing.
+ */
 function decodeStoreCount(row, field) {
     return row ? (0, coercion_1.asNumber)(row.count, field) : 0;
 }
-function decodeSignalRemoteIdentity(raw) {
-    return (0, coercion_1.asBytes)(raw, 'signal_identity.identity_key');
-}

package/dist/signal/group/SenderKeyChain.js

@@ -5,9 +5,10 @@ exports.deriveSenderKeyMsgKey = deriveSenderKeyMsgKey;
 const _crypto_1 = require("../../crypto/index.js");
 const constants_1 = require("../constants");
 const bytes_1 = require("../../util/bytes");
-async function selectMessageKey(senderKey, targetIteration) {
+// eslint-disable-next-line @typescript-eslint/require-await
+async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
     const delta = targetIteration - senderKey.iteration;
-    if (delta > constants_1.SENDER_KEY_FUTURE_MESSAGES_MAX) {
+    if (delta > (futureMessagesMax ?? constants_1.SENDER_KEY_FUTURE_MESSAGES_MAX)) {
         throw new Error('sender key message is too far in future');
     }
     const currentUnused = senderKey.unusedMessageKeys ?? [];
@@ -26,9 +27,9 @@ async function selectMessageKey(senderKey, targetIteration) {
             }
         };
     }
-    let chainState = await createSenderChainState(senderKey.chainKey);
-    const firstDerived = await deriveSenderKeyMsgKeyFromState(senderKey.iteration, chainState);
-    chainState = firstDerived.nextState;
+    let chainKey = ensureChainKey(senderKey.chainKey);
+    const firstDerived = deriveSenderKeyMsgKeyFromChainKey(senderKey.iteration, chainKey);
+    chainKey = firstDerived.nextChainKey;
     let messageKey = firstDerived.messageKey;
     if (delta === 0) {
         return {
@@ -36,7 +37,7 @@ async function selectMessageKey(senderKey, targetIteration) {
             updatedRecord: {
                 ...senderKey,
                 iteration: targetIteration + 1,
-                chainKey: chainState.chainKey,
+                chainKey,
                 unusedMessageKeys: currentUnused
             }
         };
@@ -54,8 +55,8 @@ async function selectMessageKey(senderKey, targetIteration) {
         else {
             nextUnused.push(messageKey);
         }
-        const derived = await deriveSenderKeyMsgKeyFromState(iteration, chainState);
-        chainState = derived.nextState;
+        const derived = deriveSenderKeyMsgKeyFromChainKey(iteration, chainKey);
+        chainKey = derived.nextChainKey;
         messageKey = derived.messageKey;
     }
     return {
@@ -63,41 +64,25 @@ async function selectMessageKey(senderKey, targetIteration) {
         updatedRecord: {
             ...senderKey,
             iteration: targetIteration + 1,
-            chainKey: chainState.chainKey,
+            chainKey,
             unusedMessageKeys: nextUnused
         }
     };
 }
-async function deriveSenderKeyMsgKey(iteration, chainKey) {
-    const state = await createSenderChainState(chainKey);
-    const derived = await deriveSenderKeyMsgKeyFromState(iteration, state);
-    return {
-        nextChainKey: derived.nextState.chainKey,
-        messageKey: derived.messageKey
-    };
+function deriveSenderKeyMsgKey(iteration, chainKey) {
+    return deriveSenderKeyMsgKeyFromChainKey(iteration, ensureChainKey(chainKey));
 }
-async function createSenderChainState(chainKey) {
+function ensureChainKey(chainKey) {
     (0, bytes_1.assertByteLength)(chainKey, 32, 'sender key chainKey must be 32 bytes');
-    return {
-        chainKey,
-        hmacKey: await (0, _crypto_1.importHmacKey)(chainKey)
-    };
+    return chainKey;
 }
-async function deriveSenderKeyMsgKeyFromState(iteration, state) {
-    const [nextChainRaw, messageInputKey] = await Promise.all([
-        (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.CHAIN_KEY_LABEL),
-        (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.MESSAGE_KEY_LABEL)
-    ]);
+function deriveSenderKeyMsgKeyFromChainKey(iteration, chainKey) {
+    const nextChainRaw = (0, _crypto_1.hmacSha256Sign)(chainKey, constants_1.CHAIN_KEY_LABEL);
+    const messageInputKey = (0, _crypto_1.hmacSha256Sign)(chainKey, constants_1.MESSAGE_KEY_LABEL);
     const nextChainKey = nextChainRaw.subarray(0, 32);
-    const [nextHmacKey, messageSeed] = await Promise.all([
-        (0, _crypto_1.importHmacKey)(nextChainKey),
-        (0, _crypto_1.hkdf)(messageInputKey, null, constants_1.WHISPER_GROUP_INFO, 50)
-    ]);
+    const messageSeed = (0, _crypto_1.hkdf)(messageInputKey, null, constants_1.WHISPER_GROUP_INFO, 50);
     return {
-        nextState: {
-            chainKey: nextChainKey,
-            hmacKey: nextHmacKey
-        },
+        nextChainKey,
         messageKey: {
             iteration,
             seed: messageSeed

package/dist/signal/group/SenderKeyCodec.js

@@ -20,13 +20,12 @@ function parseDistributionPayload(payload) {
         decoded.signingKey === undefined) {
         throw new Error('invalid sender key distribution message');
     }
-    const chainKey = (0, bytes_1.toBytesView)(decoded.chainKey);
-    (0, bytes_1.assertByteLength)(chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
+    (0, bytes_1.assertByteLength)(decoded.chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,
-        chainKey,
-        signingPublicKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(decoded.signingKey))
+        chainKey: decoded.chainKey,
+        signingPublicKey: (0, _crypto_1.toSerializedPubKey)(decoded.signingKey)
     };
 }
 function parseSenderKeyMessage(versionContentMac) {
@@ -43,7 +42,7 @@ function parseSenderKeyMessage(versionContentMac) {
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,
-        ciphertext: (0, bytes_1.toBytesView)(decoded.ciphertext),
+        ciphertext: decoded.ciphertext,
         versionContentMac
     };
 }

package/dist/signal/group/SenderKeyManager.js

@@ -7,7 +7,6 @@ const _proto_1 = require("../../proto.js");
 const jid_1 = require("../../protocol/jid");
 const constants_1 = require("../api/constants");
 const constants_2 = require("../constants");
-const WaAdvSignature_1 = require("../crypto/WaAdvSignature");
 const SenderKeyChain_1 = require("../group/SenderKeyChain");
 const SenderKeyCodec_1 = require("../group/SenderKeyCodec");
 const bytes_1 = require("../../util/bytes");
@@ -20,26 +19,37 @@ function extractAesCbcParams(seed) {
         keyBytes: seed.subarray(16, 48)
     };
 }
-async function aesCbcEncryptFromSeed(seed, plaintext) {
+function aesCbcEncryptFromSeed(seed, plaintext) {
     const { keyBytes, iv } = extractAesCbcParams(seed);
-    return (0, _crypto_1.aesCbcEncrypt)(await (0, _crypto_1.importAesCbcKey)(keyBytes), iv, plaintext);
+    return (0, _crypto_1.aesCbcEncrypt)(keyBytes, iv, plaintext);
 }
-async function aesCbcDecryptFromSeed(seed, ciphertext) {
+function aesCbcDecryptFromSeed(seed, ciphertext) {
     const { keyBytes, iv } = extractAesCbcParams(seed);
-    return (0, _crypto_1.aesCbcDecrypt)(await (0, _crypto_1.importAesCbcKey)(keyBytes), iv, ciphertext);
+    return (0, _crypto_1.aesCbcDecrypt)(keyBytes, iv, ciphertext);
 }
+/**
+ * Implements the sender-key group encryption side of Signal: creates and
+ * rotates sender keys, encrypts/decrypts group messages, and tracks which
+ * participants have already received the distribution message.
+ */
 class SenderKeyManager {
-    constructor(store) {
+    constructor(store, options) {
         this.senderLock = new StoreLock_1.StoreLock();
         this.store = store;
+        this.getFutureMessagesMax = options?.getFutureMessagesMax;
+        this.skipSignatureVerification = options?.skipSignatureVerification === true;
     }
+    /**
+     * Produces the distribution message and ciphertext for `plaintext` sent by
+     * `sender` into `groupId`. Initializes a sender key when none exists yet.
+     */
     async prepareGroupEncryption(groupId, sender, plaintext) {
         return this.runWithSenderLock(groupId, sender, async () => {
             const senderKey = await this.ensureSenderKeyInternal(groupId, sender);
             if (!senderKey.signingPrivateKey) {
                 throw new Error('sender private signing key is missing');
             }
-            const derived = await (0, SenderKeyChain_1.deriveSenderKeyMsgKey)(senderKey.iteration, senderKey.chainKey);
+            const derived = (0, SenderKeyChain_1.deriveSenderKeyMsgKey)(senderKey.iteration, senderKey.chainKey);
             await this.store.upsertSenderKey({
                 ...senderKey,
                 chainKey: derived.nextChainKey,
@@ -55,14 +65,14 @@ class SenderKeyManager {
                 groupId,
                 axolotlSenderKeyDistributionMessage: (0, _crypto_1.prependVersion)(distributionProto, constants_2.SIGNAL_GROUP_VERSION)
             };
-            const messagePayload = await aesCbcEncryptFromSeed(derived.messageKey.seed, plaintext);
+            const messagePayload = aesCbcEncryptFromSeed(derived.messageKey.seed, plaintext);
             const senderKeyMessage = _proto_1.proto.SenderKeyMessage.encode({
                 id: senderKey.keyId,
                 iteration: derived.messageKey.iteration,
                 ciphertext: messagePayload
             }).finish();
             const versionedContent = (0, _crypto_1.prependVersion)(senderKeyMessage, constants_2.SIGNAL_GROUP_VERSION);
-            const signature = await (0, WaAdvSignature_1.signSignalMessage)(senderKey.signingPrivateKey, versionedContent);
+            const signature = await (0, _crypto_1.xeddsaSign)(senderKey.signingPrivateKey, versionedContent);
             if (signature.length !== constants_1.SIGNAL_SIGNATURE_LENGTH) {
                 throw new Error(`invalid sender key signature length ${signature.length}`);
             }
@@ -86,6 +96,7 @@ class SenderKeyManager {
             };
         });
     }
+    /** Filters a participant list down to those who have not yet received the current sender key distribution. */
     async filterParticipantsNeedingDistribution(groupId, senderKeyId, participants) {
         if (participants.length === 0) {
             return [];
@@ -103,6 +114,7 @@ class SenderKeyManager {
         pendingParticipants.length = pendingCount;
         return pendingParticipants;
     }
+    /** Records that the sender key was successfully delivered to the given participants. */
     async markSenderKeyDistributed(groupId, senderKeyId, participants) {
         if (participants.length === 0) {
             return;
@@ -119,6 +131,11 @@ class SenderKeyManager {
         }
         await this.store.upsertSenderKeyDistributions(distributions);
     }
+    /**
+     * Verifies (per `skipSignatureVerification`) and stores an incoming sender
+     * key distribution so subsequent group ciphertexts from `sender` can be
+     * decrypted.
+     */
     async processSenderKeyDistributionPayload(groupId, sender, payload) {
         return this.runWithSenderLock(groupId, sender, async () => {
             if (groupId.length === 0) {
@@ -146,6 +163,7 @@ class SenderKeyManager {
             return record;
         });
     }
+    /** Decrypts an incoming sender-key group ciphertext into plaintext. */
     async decryptGroupMessage(payload) {
         return this.runWithSenderLock(payload.groupId, payload.sender, async () => {
             const parsed = (0, SenderKeyCodec_1.parseSenderKeyMessage)(payload.ciphertext);
@@ -166,15 +184,17 @@ class SenderKeyManager {
                 parsed.iteration !== payload.iteration) {
                 throw new Error('sender key iteration mismatch');
             }
-            const signedContent = parsed.versionContentMac.subarray(0, parsed.versionContentMac.length - constants_1.SIGNAL_SIGNATURE_LENGTH);
-            const signature = parsed.versionContentMac.subarray(parsed.versionContentMac.length - constants_1.SIGNAL_SIGNATURE_LENGTH);
-            const validSignature = await (0, WaAdvSignature_1.verifySignalSignature)(senderKey.signingPublicKey, signedContent, signature);
-            if (!validSignature) {
-                throw new Error('invalid sender key signature');
+            if (!this.skipSignatureVerification) {
+                const signedContent = parsed.versionContentMac.subarray(0, parsed.versionContentMac.length - constants_1.SIGNAL_SIGNATURE_LENGTH);
+                const signature = parsed.versionContentMac.subarray(parsed.versionContentMac.length - constants_1.SIGNAL_SIGNATURE_LENGTH);
+                const validSignature = await (0, _crypto_1.xeddsaVerify)((0, _crypto_1.toRawPubKey)(senderKey.signingPublicKey), signedContent, signature);
+                if (!validSignature) {
+                    throw new Error('invalid sender key signature');
+                }
             }
-            const selected = await (0, SenderKeyChain_1.selectMessageKey)(senderKey, parsed.iteration);
+            const selected = await (0, SenderKeyChain_1.selectMessageKey)(senderKey, parsed.iteration, this.getFutureMessagesMax?.());
             // Keep decrypt + persist ordered: failed decrypt must not advance sender-key state.
-            const plaintext = await aesCbcDecryptFromSeed(selected.messageKey.seed, parsed.ciphertext);
+            const plaintext = aesCbcDecryptFromSeed(selected.messageKey.seed, parsed.ciphertext);
             await this.store.upsertSenderKey(selected.updatedRecord);
             return plaintext;
         });