zapo-js 0.1.0 → 0.1.2

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

@@ -1,20 +1,10 @@
-import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS } from '../../protocol/constants.js';
+import { WA_DEFAULTS, 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;
-}
+import { decodeNodeContentBase64OrBytes, findNodeChildrenByTags, findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { assertIqResult } from '../../transport/node/query.js';
 export class SignalMissingPreKeysSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -38,16 +28,7 @@ export class SignalMissingPreKeysSyncApi {
         return parsed;
     }
     parseFetchMissingPreKeysResponse(node, requestedTargets) {
-        if (node.tag !== WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid missing prekeys response tag: ${node.tag}`);
-        }
-        if (node.attrs.type === WA_IQ_TYPES.ERROR) {
-            const error = parseIqError(node);
-            throw new Error(`missing prekeys iq failed (${error.code}: ${error.text})`);
-        }
-        if (node.attrs.type !== WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid missing prekeys response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        assertIqResult(node, 'missing prekeys');
         const listNode = findNodeChild(node, WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('missing prekeys response missing list node');
@@ -75,67 +56,94 @@ export 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 } = splitJid(userJid);
         const devices = getNodeChildrenByTag(node, WA_NODE_TAGS.DEVICE);
-        return devices.map((deviceNode, index) => {
-            const deviceId = parseDeviceId(deviceNode.attrs.id, `missing prekeys user[${userJid}] device[${index}].id`);
-            const registrationNode = findNodeChild(deviceNode, WA_NODE_TAGS.REGISTRATION);
-            const identityNode = findNodeChild(deviceNode, WA_NODE_TAGS.IDENTITY);
-            const signedKeyNode = findNodeChild(deviceNode, WA_NODE_TAGS.SKEY);
+        const bundles = new Array(devices.length);
+        for (let index = 0; index < devices.length; index += 1) {
+            const deviceNode = devices[index];
+            const deviceIdValue = deviceNode.attrs.id;
+            if (!deviceIdValue) {
+                throw new Error(`missing prekeys device[${index}].id is missing`);
+            }
+            const deviceId = Number.parseInt(deviceIdValue, 10);
+            if (!Number.isSafeInteger(deviceId) || deviceId < 0) {
+                throw new Error(`missing prekeys device[${index}].id is invalid`);
+            }
+            const [registrationNode, identityNode, signedKeyNode, oneTimeNode, deviceIdentityNode] = findNodeChildrenByTags(deviceNode, [
+                WA_NODE_TAGS.REGISTRATION,
+                WA_NODE_TAGS.IDENTITY,
+                WA_NODE_TAGS.SKEY,
+                WA_NODE_TAGS.KEY,
+                WA_NODE_TAGS.DEVICE_IDENTITY
+            ]);
             if (!registrationNode || !identityNode || !signedKeyNode) {
                 throw new Error(`missing prekeys device payload is incomplete for ${userJid}`);
             }
-            const signedKeyIdNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.ID);
-            const signedKeyValueNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.VALUE);
-            const signedKeySignatureNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.SIGNATURE);
+            const [signedKeyIdNode, signedKeyValueNode, signedKeySignatureNode] = findNodeChildrenByTags(signedKeyNode, [
+                WA_NODE_TAGS.ID,
+                WA_NODE_TAGS.VALUE,
+                WA_NODE_TAGS.SIGNATURE
+            ]);
             if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
                 throw new Error(`missing prekeys signed pre-key is incomplete for ${userJid}`);
             }
-            const oneTimeNode = findNodeChild(deviceNode, WA_NODE_TAGS.KEY);
-            const oneTimeIdNode = oneTimeNode
-                ? findNodeChild(oneTimeNode, WA_NODE_TAGS.ID)
-                : undefined;
-            const oneTimeValueNode = oneTimeNode
-                ? findNodeChild(oneTimeNode, WA_NODE_TAGS.VALUE)
-                : undefined;
+            let oneTimeIdNode;
+            let oneTimeValueNode;
+            if (oneTimeNode) {
+                const oneTimeNodes = findNodeChildrenByTags(oneTimeNode, [
+                    WA_NODE_TAGS.ID,
+                    WA_NODE_TAGS.VALUE
+                ]);
+                oneTimeIdNode = oneTimeNodes[0];
+                oneTimeValueNode = oneTimeNodes[1];
+            }
             if (oneTimeNode && (!oneTimeIdNode || !oneTimeValueNode)) {
                 throw new Error(`missing prekeys one-time key is incomplete for ${userJid}`);
             }
-            const deviceIdentityNode = findNodeChild(deviceNode, WA_NODE_TAGS.DEVICE_IDENTITY);
-            const bundle = {
+            const baseBundle = {
                 regId: parseUint(decodeExactLength(registrationNode.content, 'missing prekeys device registration', SIGNAL_REGISTRATION_ID_LENGTH), 'missing prekeys device registration'),
                 identity: decodeExactLength(identityNode.content, 'missing prekeys device identity', SIGNAL_KEY_DATA_LENGTH),
                 signedKey: {
                     id: parseUint(decodeExactLength(signedKeyIdNode.content, 'missing prekeys device skey.id', SIGNAL_KEY_ID_LENGTH), 'missing prekeys device skey.id'),
                     publicKey: decodeExactLength(signedKeyValueNode.content, 'missing prekeys device skey.value', SIGNAL_KEY_DATA_LENGTH),
                     signature: decodeExactLength(signedKeySignatureNode.content, 'missing prekeys device skey.signature', SIGNAL_SIGNATURE_LENGTH)
-                },
-                ...(oneTimeIdNode && oneTimeValueNode
-                    ? {
-                        oneTimeKey: {
-                            id: parseUint(decodeExactLength(oneTimeIdNode.content, 'missing prekeys device key.id', SIGNAL_KEY_ID_LENGTH), 'missing prekeys device key.id'),
-                            publicKey: decodeExactLength(oneTimeValueNode.content, 'missing prekeys device key.value', SIGNAL_KEY_DATA_LENGTH)
-                        }
-                    }
-                    : {})
+                }
             };
-            return {
-                deviceJid: deviceId === 0 ? userJid : `${user}:${deviceId}@${server}`,
-                bundle,
-                ...(deviceIdentityNode
-                    ? {
-                        deviceIdentity: decodeNodeContentBase64OrBytes(deviceIdentityNode.content, 'missing prekeys device device-identity')
+            const bundle = oneTimeIdNode && oneTimeValueNode
+                ? {
+                    ...baseBundle,
+                    oneTimeKey: {
+                        id: parseUint(decodeExactLength(oneTimeIdNode.content, 'missing prekeys device key.id', SIGNAL_KEY_ID_LENGTH), 'missing prekeys device key.id'),
+                        publicKey: decodeExactLength(oneTimeValueNode.content, 'missing prekeys device key.value', SIGNAL_KEY_DATA_LENGTH)
                     }
-                    : {})
-            };
-        });
+                }
+                : baseBundle;
+            let deviceIdentity;
+            if (deviceIdentityNode) {
+                deviceIdentity = decodeNodeContentBase64OrBytes(deviceIdentityNode.content, 'missing prekeys device device-identity');
+            }
+            bundles[index] = deviceIdentity
+                ? {
+                    deviceJid: deviceId === 0 ? userJid : `${user}:${deviceId}@${server}`,
+                    bundle,
+                    deviceIdentity
+                }
+                : {
+                    deviceJid: deviceId === 0 ? userJid : `${user}:${deviceId}@${server}`,
+                    bundle
+                };
+        }
+        return bundles;
     }
 }

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

@@ -2,6 +2,7 @@ import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol
 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';
+import { assertIqResult } from '../../transport/node/query.js';
 export class SignalSessionSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -40,7 +41,20 @@ export 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: WA_NODE_TAGS.USER,
+                attrs: target.reasonIdentity === true
+                    ? { jid: target.jid, reason: 'identity' }
+                    : { jid: target.jid }
+            };
+        }
         this.logger.debug('signal fetch key bundles request', {
             targets: mergedTargets.length,
             timeoutMs
@@ -56,34 +70,14 @@ export class SignalSessionSyncApi {
                 {
                     tag: WA_NODE_TAGS.KEY,
                     attrs: {},
-                    content: mergedTargets.map((target) => ({
-                        tag: WA_NODE_TAGS.USER,
-                        attrs: {
-                            jid: target.jid,
-                            ...(target.reasonIdentity === true ? { reason: 'identity' } : {})
-                        }
-                    }))
+                    content: userNodes
                 }
             ]
         }, timeoutMs);
         return this.parseFetchKeyBundleResponse(responseNode, mergedTargets);
     }
     parseFetchKeyBundleResponse(node, requestedTargets) {
-        if (node.tag !== WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid key bundle response tag: ${node.tag}`);
-        }
-        if (node.attrs.type === WA_IQ_TYPES.ERROR) {
-            const errorNode = findNodeChild(node, WA_NODE_TAGS.ERROR);
-            if (!errorNode) {
-                throw new Error(`key bundle iq error for ${node.attrs.id ?? 'unknown id'}`);
-            }
-            const code = errorNode.attrs.code ?? 'unknown';
-            const text = errorNode.attrs.text ?? errorNode.attrs.type ?? 'unknown';
-            throw new Error(`key bundle iq error (${code} ${text})`);
-        }
-        if (node.attrs.type !== WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid key bundle response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        assertIqResult(node, 'key bundle');
         const listNode = findNodeChild(node, WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('key bundle response missing list node');
@@ -115,16 +109,15 @@ export 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 = findNodeChild(node, WA_NODE_TAGS.REGISTRATION);

package/dist/esm/signal/crypto/WaAdvSignature.js

@@ -4,10 +4,10 @@ import { encodeExtendedPoint, scalarMultBase } from '../../crypto/math/edwards.j
 import { bytesToBigIntLE, bigIntToBytesLE } from '../../crypto/math/le.js';
 import { modGroup } from '../../crypto/math/mod.js';
 import { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE, SIGNAL_PREFIX_SIGNATURE_RANDOM } from '../crypto/constants.js';
-import { concatBytes } from '../../util/bytes.js';
+import { assertByteLength, concatBytes } from '../../util/bytes.js';
 export { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE } from '../crypto/constants.js';
 export async function verifySignalSignature(publicKey, message, signature) {
-    if (signature.length !== 64) {
+    if (!assertByteLength(signature, 64, 'invalid signal signature length', false)) {
         return false;
     }
     if ((signature[63] & 0x60) !== 0) {
@@ -21,9 +21,7 @@ export async function verifySignalSignature(publicKey, message, signature) {
     return ed25519VerifyRaw(edPublic, signalSignature, message);
 }
 export async function signSignalMessage(privateKey, message) {
-    if (privateKey.length !== 32) {
-        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
-    }
+    assertByteLength(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
     const clampedPrivateKey = clampCurvePrivateKeyInPlace(privateKey);
     const privateScalar = bytesToBigIntLE(clampedPrivateKey);
     const encodedPublic = encodeExtendedPoint(scalarMultBase(privateScalar));

package/dist/esm/signal/group/SenderKeyChain.js

@@ -1,6 +1,6 @@
 import { hkdf, importHmacKey, hmacSign } from '../../crypto/index.js';
 import { CHAIN_KEY_LABEL, MAX_UNUSED_KEYS, MESSAGE_KEY_LABEL, SENDER_KEY_FUTURE_MESSAGES_MAX, WHISPER_GROUP_INFO } from '../constants.js';
-import { removeAt } from '../../util/bytes.js';
+import { assertByteLength, removeAt } from '../../util/bytes.js';
 export async function selectMessageKey(senderKey, targetIteration) {
     const delta = targetIteration - senderKey.iteration;
     if (delta > SENDER_KEY_FUTURE_MESSAGES_MAX) {
@@ -26,24 +26,33 @@ export 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 - 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 - 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,
@@ -64,20 +73,16 @@ export async function deriveSenderKeyMsgKey(iteration, chainKey) {
     };
 }
 async function createSenderChainState(chainKey) {
-    if (chainKey.length !== 32) {
-        throw new Error('sender key chainKey must be 32 bytes');
-    }
+    assertByteLength(chainKey, 32, 'sender key chainKey must be 32 bytes');
     return {
         chainKey,
         hmacKey: await importHmacKey(chainKey)
     };
 }
 async function deriveSenderKeyMsgKeyFromState(iteration, state) {
-    const nextChainRawPromise = hmacSign(state.hmacKey, CHAIN_KEY_LABEL);
-    const messageInputKeyPromise = hmacSign(state.hmacKey, MESSAGE_KEY_LABEL);
     const [nextChainRaw, messageInputKey] = await Promise.all([
-        nextChainRawPromise,
-        messageInputKeyPromise
+        hmacSign(state.hmacKey, CHAIN_KEY_LABEL),
+        hmacSign(state.hmacKey, MESSAGE_KEY_LABEL)
     ]);
     const nextChainKey = nextChainRaw.subarray(0, 32);
     const [nextHmacKey, messageSeed] = await Promise.all([

package/dist/esm/signal/group/SenderKeyCodec.js

@@ -1,7 +1,7 @@
 import { readVersionedContent, toSerializedPubKey } from '../../crypto/index.js';
 import { proto } from '../../proto.js';
 import { SIGNATURE_SIZE, SIGNAL_GROUP_VERSION } from '../constants.js';
-import { toBytesView } from '../../util/bytes.js';
+import { assertByteLength, toBytesView } from '../../util/bytes.js';
 export function parseDistributionPayload(payload) {
     const body = readVersionedContent(payload, SIGNAL_GROUP_VERSION, 0);
     const decoded = proto.SenderKeyDistributionMessage.decode(body);
@@ -16,9 +16,7 @@ export function parseDistributionPayload(payload) {
         throw new Error('invalid sender key distribution message');
     }
     const chainKey = toBytesView(decoded.chainKey);
-    if (chainKey.length !== 32) {
-        throw new Error('sender key distribution chainKey must be 32 bytes');
-    }
+    assertByteLength(chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,

package/dist/esm/signal/group/SenderKeyManager.js

@@ -63,12 +63,16 @@ export 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) {
@@ -84,13 +88,15 @@ export 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) {
@@ -159,13 +165,17 @@ export class SenderKeyManager {
         if (existing) {
             return existing;
         }
-        const signingKeyPair = await X25519.generateKeyPair();
+        const [signingKeyPair, keyId, chainKey] = await Promise.all([
+            X25519.generateKeyPair(),
+            randomIntAsync(1, 2147483647),
+            randomBytesAsync(32)
+        ]);
         const created = {
             groupId,
             sender,
-            keyId: await randomIntAsync(1, 2147483647),
+            keyId,
             iteration: 0,
-            chainKey: await randomBytesAsync(32),
+            chainKey,
             signingPublicKey: toSerializedPubKey(signingKeyPair.pubKey),
             signingPrivateKey: signingKeyPair.privKey,
             unusedMessageKeys: []

package/dist/esm/signal/index.js

@@ -9,3 +9,4 @@ export { SignalSessionSyncApi } from './api/SignalSessionSyncApi.js';
 export { SenderKeyManager } from './group/SenderKeyManager.js';
 export { createAndStoreInitialKeys } from './registration/utils.js';
 export { SignalProtocol } from './session/SignalProtocol.js';
+export { createSignalSessionResolver } from './session/resolver.js';

package/dist/esm/signal/session/SignalProtocol.js

@@ -5,6 +5,9 @@ import { decryptMsg, decryptMsgFromSession, encryptMsg } from '../session/Signal
 import { deserializeMsg, deserializePkMsg, requirePreKey, requireSignedPreKey } from '../session/SignalSerializer.js';
 import { detachSession, findMatchingSession, generateSerializedKeyPair, initiateSessionIncoming, initiateSessionOutgoing, requireLocalIdentity, toSerializedKeyPair } from '../session/SignalSession.js';
 import { uint8Equal } from '../../util/bytes.js';
+function signalAddressMapKey(address) {
+    return `${address.user}\u0001${address.server ?? ''}\u0001${address.device}`;
+}
 export class SignalProtocol {
     constructor(store, logger = new ConsoleLogger('info')) {
         this.store = store;
@@ -27,23 +30,55 @@ export 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 &&
-            !uint8Equal(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 &&
+                !uint8Equal(toSerializedPubKey(request.expectedIdentity), session.remote.pubKey)) {
+                throw new Error('identity mismatch');
+            }
+            const [updatedSession, encrypted] = await encryptMsg(session, request.plaintext);
+            latestSessionByAddress.set(addressKey, updatedSession);
+            sessionUpdatesByAddress.set(addressKey, {
+                address,
+                session: updatedSession
+            });
+            if (!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 encryptMsg(session, plaintext);
-        await this.store.setSession(address, updatedSession);
-        if (!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/esm/signal/session/SignalRatchet.js

@@ -51,24 +51,33 @@ export 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 - 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 - 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/esm/signal/session/SignalSession.js

@@ -20,16 +20,21 @@ export function findMatchingSession(session, sessionBaseKey) {
     if (session.aliceBaseKey && uint8Equal(session.aliceBaseKey, serializedBaseKey)) {
         return session;
     }
-    const previousSessionIndex = session.prevSessions.findIndex((prev) => !!prev.aliceBaseKey && 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 ||
+            !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;