zapo-js 0.1.0 → 0.1.2

package/dist/signal/api/SignalMissingPreKeysSyncApi.js

@@ -8,16 +8,6 @@ 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;
@@ -41,16 +31,7 @@ class SignalMissingPreKeysSyncApi {
         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'}`);
-        }
+        (0, query_1.assertIqResult)(node, 'missing prekeys');
         const listNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('missing prekeys response missing list node');
@@ -78,68 +59,95 @@ class SignalMissingPreKeysSyncApi {
                 devices: this.parseUserDevices(userNode, userJid)
             });
         }
-        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) ?? {
                 userJid: target.userJid,
                 errorText: 'missing user in key_fetch response'
-            });
-        });
+            };
+        }
+        return results;
     }
     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);
+        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] = (0, helpers_1.findNodeChildrenByTags)(deviceNode, [
+                constants_1.WA_NODE_TAGS.REGISTRATION,
+                constants_1.WA_NODE_TAGS.IDENTITY,
+                constants_1.WA_NODE_TAGS.SKEY,
+                constants_1.WA_NODE_TAGS.KEY,
+                constants_1.WA_NODE_TAGS.DEVICE_IDENTITY
+            ]);
             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);
+            const [signedKeyIdNode, signedKeyValueNode, signedKeySignatureNode] = (0, helpers_1.findNodeChildrenByTags)(signedKeyNode, [
+                constants_1.WA_NODE_TAGS.ID,
+                constants_1.WA_NODE_TAGS.VALUE,
+                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;
+            let oneTimeIdNode;
+            let oneTimeValueNode;
+            if (oneTimeNode) {
+                const oneTimeNodes = (0, helpers_1.findNodeChildrenByTags)(oneTimeNode, [
+                    constants_1.WA_NODE_TAGS.ID,
+                    constants_1.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 = (0, helpers_1.findNodeChild)(deviceNode, constants_1.WA_NODE_TAGS.DEVICE_IDENTITY);
-            const bundle = {
+            const baseBundle = {
                 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')
+            const bundle = oneTimeIdNode && oneTimeValueNode
+                ? {
+                    ...baseBundle,
+                    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)
                     }
-                    : {})
-            };
-        });
+                }
+                : baseBundle;
+            let deviceIdentity;
+            if (deviceIdentityNode) {
+                deviceIdentity = (0, helpers_1.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;
     }
 }
 exports.SignalMissingPreKeysSyncApi = SignalMissingPreKeysSyncApi;

package/dist/signal/api/SignalSessionSyncApi.js

@@ -5,6 +5,7 @@ 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");
 class SignalSessionSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -43,7 +44,20 @@ class SignalSessionSyncApi {
                 reasonIdentity: (previous?.reasonIdentity ?? false) || target.reasonIdentity === true
             });
         }
-        const mergedTargets = [...targetByJid.values()];
+        const mergedTargets = [];
+        for (const target of targetByJid.values()) {
+            mergedTargets.push(target);
+        }
+        const userNodes = new Array(mergedTargets.length);
+        for (let index = 0; index < mergedTargets.length; index += 1) {
+            const target = mergedTargets[index];
+            userNodes[index] = {
+                tag: constants_1.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
@@ -59,34 +73,14 @@ class SignalSessionSyncApi {
                 {
                     tag: constants_1.WA_NODE_TAGS.KEY,
                     attrs: {},
-                    content: mergedTargets.map((target) => ({
-                        tag: constants_1.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 !== constants_1.WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid key bundle 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(`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 !== constants_1.WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid key bundle response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        (0, query_1.assertIqResult)(node, 'key bundle');
         const listNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('key bundle response missing list node');
@@ -118,16 +112,15 @@ class SignalSessionSyncApi {
                 ...(parsed.deviceIdentity ? { deviceIdentity: parsed.deviceIdentity } : {})
             });
         }
-        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) ?? {
                 jid: target.jid,
                 errorText: 'missing key bundle user in response'
             };
-        });
+        }
+        return output;
     }
     parseUserKeyBundle(node) {
         const registrationNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.REGISTRATION);

package/dist/signal/crypto/WaAdvSignature.js

@@ -19,7 +19,7 @@ Object.defineProperty(exports, "ADV_PREFIX_DEVICE_SIGNATURE", { enumerable: true
 Object.defineProperty(exports, "ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE; } });
 Object.defineProperty(exports, "ADV_PREFIX_HOSTED_DEVICE_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE; } });
 async function verifySignalSignature(publicKey, message, signature) {
-    if (signature.length !== 64) {
+    if (!(0, bytes_1.assertByteLength)(signature, 64, 'invalid signal signature length', false)) {
         return false;
     }
     if ((signature[63] & 0x60) !== 0) {
@@ -33,9 +33,7 @@ async function verifySignalSignature(publicKey, message, signature) {
     return (0, _crypto_1.ed25519VerifyRaw)(edPublic, signalSignature, message);
 }
 async function signSignalMessage(privateKey, message) {
-    if (privateKey.length !== 32) {
-        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
-    }
+    (0, bytes_1.assertByteLength)(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
     const clampedPrivateKey = (0, X25519_1.clampCurvePrivateKeyInPlace)(privateKey);
     const privateScalar = (0, le_1.bytesToBigIntLE)(clampedPrivateKey);
     const encodedPublic = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(privateScalar));

package/dist/signal/group/SenderKeyChain.js

@@ -30,24 +30,33 @@ async function selectMessageKey(senderKey, targetIteration) {
     const firstDerived = await deriveSenderKeyMsgKeyFromState(senderKey.iteration, chainState);
     chainState = firstDerived.nextState;
     let messageKey = firstDerived.messageKey;
-    let nextUnused = currentUnused.slice();
-    if (delta > 0) {
-        let overflow = delta + currentUnused.length - constants_1.MAX_UNUSED_KEYS;
+    if (delta === 0) {
+        return {
+            messageKey,
+            updatedRecord: {
+                ...senderKey,
+                iteration: targetIteration + 1,
+                chainKey: chainState.chainKey,
+                unusedMessageKeys: currentUnused
+            }
+        };
+    }
+    const nextUnused = currentUnused.slice();
+    let overflow = delta + currentUnused.length - constants_1.MAX_UNUSED_KEYS;
+    if (overflow > 0) {
+        nextUnused.splice(0, overflow);
+        overflow -= currentUnused.length;
+    }
+    for (let iteration = senderKey.iteration + 1; iteration <= targetIteration; iteration += 1) {
         if (overflow > 0) {
-            nextUnused = nextUnused.slice(overflow);
-            overflow -= currentUnused.length;
+            overflow -= 1;
         }
-        for (let iteration = senderKey.iteration + 1; iteration <= targetIteration; iteration += 1) {
-            if (overflow > 0) {
-                overflow -= 1;
-            }
-            else {
-                nextUnused.push(messageKey);
-            }
-            const derived = await deriveSenderKeyMsgKeyFromState(iteration, chainState);
-            chainState = derived.nextState;
-            messageKey = derived.messageKey;
+        else {
+            nextUnused.push(messageKey);
         }
+        const derived = await deriveSenderKeyMsgKeyFromState(iteration, chainState);
+        chainState = derived.nextState;
+        messageKey = derived.messageKey;
     }
     return {
         messageKey,
@@ -68,20 +77,16 @@ async function deriveSenderKeyMsgKey(iteration, chainKey) {
     };
 }
 async function createSenderChainState(chainKey) {
-    if (chainKey.length !== 32) {
-        throw new Error('sender key chainKey must be 32 bytes');
-    }
+    (0, bytes_1.assertByteLength)(chainKey, 32, 'sender key chainKey must be 32 bytes');
     return {
         chainKey,
         hmacKey: await (0, _crypto_1.importHmacKey)(chainKey)
     };
 }
 async function deriveSenderKeyMsgKeyFromState(iteration, state) {
-    const nextChainRawPromise = (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.CHAIN_KEY_LABEL);
-    const messageInputKeyPromise = (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.MESSAGE_KEY_LABEL);
     const [nextChainRaw, messageInputKey] = await Promise.all([
-        nextChainRawPromise,
-        messageInputKeyPromise
+        (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.CHAIN_KEY_LABEL),
+        (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.MESSAGE_KEY_LABEL)
     ]);
     const nextChainKey = nextChainRaw.subarray(0, 32);
     const [nextHmacKey, messageSeed] = await Promise.all([

package/dist/signal/group/SenderKeyCodec.js

@@ -20,9 +20,7 @@ function parseDistributionPayload(payload) {
         throw new Error('invalid sender key distribution message');
     }
     const chainKey = (0, bytes_1.toBytesView)(decoded.chainKey);
-    if (chainKey.length !== 32) {
-        throw new Error('sender key distribution chainKey must be 32 bytes');
-    }
+    (0, bytes_1.assertByteLength)(chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,

package/dist/signal/group/SenderKeyManager.js

@@ -66,12 +66,16 @@ class SenderKeyManager {
         }
         const senderKey = await this.ensureSenderKey(groupId, sender);
         const timestampMs = Date.now();
-        await this.store.upsertSenderKeyDistributions(participants.map((participant) => ({
-            groupId,
-            sender: participant,
-            keyId: senderKey.keyId,
-            timestampMs
-        })));
+        const distributions = new Array(participants.length);
+        for (let index = 0; index < participants.length; index += 1) {
+            distributions[index] = {
+                groupId,
+                sender: participants[index],
+                keyId: senderKey.keyId,
+                timestampMs
+            };
+        }
+        await this.store.upsertSenderKeyDistributions(distributions);
     }
     async processSenderKeyDistributionPayload(groupId, sender, payload) {
         if (groupId.length === 0) {
@@ -87,13 +91,15 @@ class SenderKeyManager {
             signingPublicKey: parsed.signingPublicKey,
             unusedMessageKeys: []
         };
-        await this.store.upsertSenderKey(record);
-        await this.store.upsertSenderKeyDistribution({
-            groupId,
-            sender,
-            keyId: parsed.keyId,
-            timestampMs: Date.now()
-        });
+        await Promise.all([
+            this.store.upsertSenderKey(record),
+            this.store.upsertSenderKeyDistribution({
+                groupId,
+                sender,
+                keyId: parsed.keyId,
+                timestampMs: Date.now()
+            })
+        ]);
         return record;
     }
     async encryptGroupMessage(groupId, sender, plaintext) {
@@ -162,13 +168,17 @@ class SenderKeyManager {
         if (existing) {
             return existing;
         }
-        const signingKeyPair = await _crypto_1.X25519.generateKeyPair();
+        const [signingKeyPair, keyId, chainKey] = await Promise.all([
+            _crypto_1.X25519.generateKeyPair(),
+            (0, _crypto_1.randomIntAsync)(1, 2147483647),
+            (0, _crypto_1.randomBytesAsync)(32)
+        ]);
         const created = {
             groupId,
             sender,
-            keyId: await (0, _crypto_1.randomIntAsync)(1, 2147483647),
+            keyId,
             iteration: 0,
-            chainKey: await (0, _crypto_1.randomBytesAsync)(32),
+            chainKey,
             signingPublicKey: (0, _crypto_1.toSerializedPubKey)(signingKeyPair.pubKey),
             signingPrivateKey: signingKeyPair.privKey,
             unusedMessageKeys: []

package/dist/signal/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignalProtocol = exports.createAndStoreInitialKeys = exports.SenderKeyManager = exports.SignalSessionSyncApi = exports.SignalRotateKeyApi = exports.SignalMissingPreKeysSyncApi = exports.SignalIdentitySyncApi = exports.SignalDeviceSyncApi = exports.SignalDigestSyncApi = exports.parsePreKeyUploadFailure = exports.buildPreKeyUploadIq = exports.generateSignedPreKey = exports.generateRegistrationInfo = exports.generateRegistrationId = exports.generatePreKeyPair = void 0;
+exports.createSignalSessionResolver = exports.SignalProtocol = exports.createAndStoreInitialKeys = exports.SenderKeyManager = exports.SignalSessionSyncApi = exports.SignalRotateKeyApi = exports.SignalMissingPreKeysSyncApi = exports.SignalIdentitySyncApi = exports.SignalDeviceSyncApi = exports.SignalDigestSyncApi = exports.parsePreKeyUploadFailure = exports.buildPreKeyUploadIq = exports.generateSignedPreKey = exports.generateRegistrationInfo = exports.generateRegistrationId = exports.generatePreKeyPair = void 0;
 var keygen_1 = require("./registration/keygen");
 Object.defineProperty(exports, "generatePreKeyPair", { enumerable: true, get: function () { return keygen_1.generatePreKeyPair; } });
 Object.defineProperty(exports, "generateRegistrationId", { enumerable: true, get: function () { return keygen_1.generateRegistrationId; } });
@@ -27,3 +27,5 @@ var utils_1 = require("./registration/utils");
 Object.defineProperty(exports, "createAndStoreInitialKeys", { enumerable: true, get: function () { return utils_1.createAndStoreInitialKeys; } });
 var SignalProtocol_1 = require("./session/SignalProtocol");
 Object.defineProperty(exports, "SignalProtocol", { enumerable: true, get: function () { return SignalProtocol_1.SignalProtocol; } });
+var resolver_1 = require("./session/resolver");
+Object.defineProperty(exports, "createSignalSessionResolver", { enumerable: true, get: function () { return resolver_1.createSignalSessionResolver; } });

package/dist/signal/session/SignalProtocol.js

@@ -8,6 +8,9 @@ const SignalRatchet_1 = require("../session/SignalRatchet");
 const SignalSerializer_1 = require("../session/SignalSerializer");
 const SignalSession_1 = require("../session/SignalSession");
 const bytes_1 = require("../../util/bytes");
+function signalAddressMapKey(address) {
+    return `${address.user}\u0001${address.server ?? ''}\u0001${address.device}`;
+}
 class SignalProtocol {
     constructor(store, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
         this.store = store;
@@ -30,23 +33,55 @@ class SignalProtocol {
         return session;
     }
     async encryptMessage(address, plaintext, expectedIdentity) {
-        const session = await this.store.getSession(address);
-        if (!session) {
-            throw new Error('signal session not found');
+        const [encrypted] = await this.encryptMessagesBatch([
+            { address, plaintext, expectedIdentity }
+        ]);
+        return encrypted;
+    }
+    async encryptMessagesBatch(requests) {
+        if (requests.length === 0) {
+            return [];
         }
-        if (expectedIdentity &&
-            !(0, bytes_1.uint8Equal)((0, _crypto_1.toSerializedPubKey)(expectedIdentity), session.remote.pubKey)) {
-            throw new Error('identity mismatch');
+        const addresses = requests.map((request) => request.address);
+        const storedSessions = await this.store.getSessionsBatch(addresses);
+        const latestSessionByAddress = new Map();
+        const sessionUpdatesByAddress = new Map();
+        const identityUpdatesByAddress = new Map();
+        const results = new Array(requests.length);
+        for (let index = 0; index < requests.length; index += 1) {
+            const request = requests[index];
+            const address = request.address;
+            const addressKey = signalAddressMapKey(address);
+            const session = latestSessionByAddress.get(addressKey) ?? storedSessions[index];
+            if (!session) {
+                throw new Error('signal session not found');
+            }
+            if (request.expectedIdentity &&
+                !(0, bytes_1.uint8Equal)((0, _crypto_1.toSerializedPubKey)(request.expectedIdentity), session.remote.pubKey)) {
+                throw new Error('identity mismatch');
+            }
+            const [updatedSession, encrypted] = await (0, SignalRatchet_1.encryptMsg)(session, request.plaintext);
+            latestSessionByAddress.set(addressKey, updatedSession);
+            sessionUpdatesByAddress.set(addressKey, {
+                address,
+                session: updatedSession
+            });
+            if (!(0, bytes_1.uint8Equal)(updatedSession.remote.pubKey, session.remote.pubKey)) {
+                identityUpdatesByAddress.set(addressKey, {
+                    address,
+                    identityKey: updatedSession.remote.pubKey
+                });
+            }
+            results[index] = {
+                ...encrypted,
+                baseKey: updatedSession.aliceBaseKey
+            };
         }
-        const [updatedSession, encrypted] = await (0, SignalRatchet_1.encryptMsg)(session, plaintext);
-        await this.store.setSession(address, updatedSession);
-        if (!(0, bytes_1.uint8Equal)(updatedSession.remote.pubKey, session.remote.pubKey)) {
-            await this.store.setRemoteIdentity(address, updatedSession.remote.pubKey);
+        await this.store.setSessionsBatch([...sessionUpdatesByAddress.values()]);
+        if (identityUpdatesByAddress.size > 0) {
+            await this.store.setRemoteIdentities([...identityUpdatesByAddress.values()]);
         }
-        return {
-            ...encrypted,
-            baseKey: updatedSession.aliceBaseKey
-        };
+        return results;
     }
     async decryptMessage(address, envelope) {
         const currentSession = await this.store.getSession(address);

package/dist/signal/session/SignalRatchet.js

@@ -59,24 +59,33 @@ async function selectMessageKey(chain, targetCounter) {
     const first = await deriveMsgKeyFromState(chain.nextMsgIndex, chainState);
     let currentMessageKey = first.messageKey;
     chainState = first.nextState;
-    let nextUnused = unused.slice();
-    if (delta > 0) {
-        let overflow = delta + unused.length - constants_1.MAX_UNUSED_KEYS;
+    if (delta === 0) {
+        return {
+            messageKey: currentMessageKey,
+            updatedChain: {
+                ratchetPubKey: chain.ratchetPubKey,
+                nextMsgIndex: targetCounter + 1,
+                chainKey: chainState.chainKey,
+                unusedMsgKeys: unused
+            }
+        };
+    }
+    const nextUnused = unused.slice();
+    let overflow = delta + unused.length - constants_1.MAX_UNUSED_KEYS;
+    if (overflow > 0) {
+        nextUnused.splice(0, overflow);
+        overflow -= unused.length;
+    }
+    for (let counter = chain.nextMsgIndex + 1; counter <= targetCounter; counter += 1) {
         if (overflow > 0) {
-            nextUnused = nextUnused.slice(overflow);
-            overflow -= unused.length;
+            overflow -= 1;
         }
-        for (let counter = chain.nextMsgIndex + 1; counter <= targetCounter; counter += 1) {
-            if (overflow > 0) {
-                overflow -= 1;
-            }
-            else {
-                nextUnused.push(currentMessageKey);
-            }
-            const derived = await deriveMsgKeyFromState(counter, chainState);
-            currentMessageKey = derived.messageKey;
-            chainState = derived.nextState;
+        else {
+            nextUnused.push(currentMessageKey);
         }
+        const derived = await deriveMsgKeyFromState(counter, chainState);
+        currentMessageKey = derived.messageKey;
+        chainState = derived.nextState;
     }
     return {
         messageKey: currentMessageKey,

package/dist/signal/session/SignalSession.js

@@ -32,16 +32,21 @@ function findMatchingSession(session, sessionBaseKey) {
     if (session.aliceBaseKey && (0, bytes_1.uint8Equal)(session.aliceBaseKey, serializedBaseKey)) {
         return session;
     }
-    const previousSessionIndex = session.prevSessions.findIndex((prev) => !!prev.aliceBaseKey && (0, bytes_1.uint8Equal)(prev.aliceBaseKey, serializedBaseKey));
-    if (previousSessionIndex !== -1) {
-        const promoted = snapshotToRecord(session.prevSessions[previousSessionIndex]);
+    for (let index = 0; index < session.prevSessions.length; index += 1) {
+        const previousSession = session.prevSessions[index];
+        if (!previousSession.aliceBaseKey ||
+            !(0, bytes_1.uint8Equal)(previousSession.aliceBaseKey, serializedBaseKey)) {
+            continue;
+        }
+        const prevSessions = [detachSession(session)];
+        for (let i = 0; i < session.prevSessions.length; i += 1) {
+            if (i !== index) {
+                prevSessions.push(session.prevSessions[i]);
+            }
+        }
         return {
-            ...promoted,
-            prevSessions: [
-                detachSession(session),
-                ...session.prevSessions.slice(0, previousSessionIndex),
-                ...session.prevSessions.slice(previousSessionIndex + 1)
-            ]
+            ...previousSession,
+            prevSessions
         };
     }
     return null;