zapo-js 0.1.1 → 0.2.0

package/dist/signal/group/SenderKeyManager.js

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SenderKeyManager = void 0;
 const _crypto_1 = require("../../crypto/index.js");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
 const _proto_1 = require("../../proto.js");
-const constants_1 = require("../constants");
+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");
@@ -27,148 +30,171 @@ async function aesCbcDecryptFromSeed(seed, ciphertext) {
 }
 class SenderKeyManager {
     constructor(store) {
+        this.senderLock = new StoreLock_1.StoreLock();
         this.store = store;
     }
-    async createSenderKeyDistributionMessage(groupId, sender) {
-        const senderKey = await this.ensureSenderKey(groupId, sender);
-        const distributionProto = _proto_1.proto.SenderKeyDistributionMessage.encode({
-            id: senderKey.keyId,
-            iteration: senderKey.iteration,
-            chainKey: senderKey.chainKey,
-            signingKey: senderKey.signingPublicKey
-        }).finish();
-        const payload = (0, _crypto_1.prependVersion)(distributionProto, constants_1.SIGNAL_GROUP_VERSION);
-        await this.store.upsertSenderKeyDistribution({
-            groupId,
-            sender,
-            keyId: senderKey.keyId,
-            timestampMs: Date.now()
+    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);
+            await this.store.upsertSenderKey({
+                ...senderKey,
+                chainKey: derived.nextChainKey,
+                iteration: derived.messageKey.iteration + 1
+            });
+            const distributionProto = _proto_1.proto.SenderKeyDistributionMessage.encode({
+                id: senderKey.keyId,
+                iteration: senderKey.iteration,
+                chainKey: senderKey.chainKey,
+                signingKey: senderKey.signingPublicKey
+            }).finish();
+            const distributionMessage = {
+                groupId,
+                axolotlSenderKeyDistributionMessage: (0, _crypto_1.prependVersion)(distributionProto, constants_2.SIGNAL_GROUP_VERSION)
+            };
+            const messagePayload = await 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);
+            if (signature.length !== constants_1.SIGNAL_SIGNATURE_LENGTH) {
+                throw new Error(`invalid sender key signature length ${signature.length}`);
+            }
+            const ciphertext = {
+                groupId,
+                sender,
+                keyId: senderKey.keyId,
+                iteration: derived.messageKey.iteration,
+                ciphertext: (0, bytes_1.concatBytes)([versionedContent, signature])
+            };
+            await this.store.upsertSenderKeyDistribution({
+                groupId,
+                sender,
+                keyId: senderKey.keyId,
+                timestampMs: Date.now()
+            });
+            return {
+                distributionMessage,
+                ciphertext,
+                keyId: senderKey.keyId
+            };
         });
-        return {
-            groupId,
-            axolotlSenderKeyDistributionMessage: payload
-        };
     }
-    async filterParticipantsNeedingDistribution(groupId, sender, participants) {
+    async filterParticipantsNeedingDistribution(groupId, senderKeyId, participants) {
         if (participants.length === 0) {
             return [];
         }
-        const senderKey = await this.ensureSenderKey(groupId, sender);
         const distributed = await this.store.getDeviceSenderKeyDistributions(groupId, participants);
-        return participants.filter((_, index) => {
+        const pendingParticipants = new Array(participants.length);
+        let pendingCount = 0;
+        for (let index = 0; index < participants.length; index += 1) {
             const record = distributed[index];
-            return !record || record.keyId !== senderKey.keyId;
-        });
+            if (!record || record.keyId !== senderKeyId) {
+                pendingParticipants[pendingCount] = participants[index];
+                pendingCount += 1;
+            }
+        }
+        pendingParticipants.length = pendingCount;
+        return pendingParticipants;
     }
-    async markSenderKeyDistributed(groupId, sender, participants) {
+    async markSenderKeyDistributed(groupId, senderKeyId, participants) {
         if (participants.length === 0) {
             return;
         }
-        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
-        })));
-    }
-    async processSenderKeyDistributionPayload(groupId, sender, payload) {
-        if (groupId.length === 0) {
-            throw new Error('sender key distribution missing groupId');
+        const distributions = new Array(participants.length);
+        for (let index = 0; index < participants.length; index += 1) {
+            distributions[index] = {
+                groupId,
+                sender: participants[index],
+                keyId: senderKeyId,
+                timestampMs
+            };
         }
-        const parsed = (0, SenderKeyCodec_1.parseDistributionPayload)(payload);
-        const record = {
-            groupId,
-            sender,
-            keyId: parsed.keyId,
-            iteration: parsed.iteration,
-            chainKey: parsed.chainKey,
-            signingPublicKey: parsed.signingPublicKey,
-            unusedMessageKeys: []
-        };
-        await this.store.upsertSenderKey(record);
-        await this.store.upsertSenderKeyDistribution({
-            groupId,
-            sender,
-            keyId: parsed.keyId,
-            timestampMs: Date.now()
-        });
-        return record;
+        await this.store.upsertSenderKeyDistributions(distributions);
     }
-    async encryptGroupMessage(groupId, sender, plaintext) {
-        const senderKey = await this.ensureSenderKey(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 messagePayload = await 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_1.SIGNAL_GROUP_VERSION);
-        const signature = await (0, WaAdvSignature_1.signSignalMessage)(senderKey.signingPrivateKey, versionedContent);
-        if (signature.length !== constants_1.SIGNATURE_SIZE) {
-            throw new Error(`invalid sender key signature length ${signature.length}`);
-        }
-        const ciphertext = (0, bytes_1.concatBytes)([versionedContent, signature]);
-        await this.store.upsertSenderKey({
-            ...senderKey,
-            chainKey: derived.nextChainKey,
-            iteration: derived.messageKey.iteration + 1
+    async processSenderKeyDistributionPayload(groupId, sender, payload) {
+        return this.runWithSenderLock(groupId, sender, async () => {
+            if (groupId.length === 0) {
+                throw new Error('sender key distribution missing groupId');
+            }
+            const parsed = (0, SenderKeyCodec_1.parseDistributionPayload)(payload);
+            const record = {
+                groupId,
+                sender,
+                keyId: parsed.keyId,
+                iteration: parsed.iteration,
+                chainKey: parsed.chainKey,
+                signingPublicKey: parsed.signingPublicKey,
+                unusedMessageKeys: []
+            };
+            await Promise.all([
+                this.store.upsertSenderKey(record),
+                this.store.upsertSenderKeyDistribution({
+                    groupId,
+                    sender,
+                    keyId: parsed.keyId,
+                    timestampMs: Date.now()
+                })
+            ]);
+            return record;
         });
-        return {
-            groupId,
-            sender,
-            keyId: senderKey.keyId,
-            iteration: derived.messageKey.iteration,
-            ciphertext
-        };
     }
     async decryptGroupMessage(payload) {
-        const parsed = (0, SenderKeyCodec_1.parseSenderKeyMessage)(payload.ciphertext);
-        const senderKey = await this.store.getDeviceSenderKey(payload.groupId, payload.sender);
-        if (!senderKey) {
-            throw new Error('missing sender key');
-        }
-        if (senderKey.keyId !== parsed.keyId) {
-            throw new Error('sender key id mismatch');
-        }
-        if (payload.keyId !== undefined &&
-            payload.keyId !== null &&
-            parsed.keyId !== payload.keyId) {
-            throw new Error('sender key id mismatch');
-        }
-        if (payload.iteration !== undefined &&
-            payload.iteration !== null &&
-            parsed.iteration !== payload.iteration) {
-            throw new Error('sender key iteration mismatch');
-        }
-        const signedContent = parsed.versionContentMac.subarray(0, parsed.versionContentMac.length - constants_1.SIGNATURE_SIZE);
-        const signature = parsed.versionContentMac.subarray(parsed.versionContentMac.length - constants_1.SIGNATURE_SIZE);
-        const validSignature = await (0, WaAdvSignature_1.verifySignalSignature)(senderKey.signingPublicKey, signedContent, signature);
-        if (!validSignature) {
-            throw new Error('invalid sender key signature');
-        }
-        const selected = await (0, SenderKeyChain_1.selectMessageKey)(senderKey, parsed.iteration);
-        const plaintext = await aesCbcDecryptFromSeed(selected.messageKey.seed, parsed.ciphertext);
-        await this.store.upsertSenderKey(selected.updatedRecord);
-        return plaintext;
+        return this.runWithSenderLock(payload.groupId, payload.sender, async () => {
+            const parsed = (0, SenderKeyCodec_1.parseSenderKeyMessage)(payload.ciphertext);
+            const senderKey = await this.store.getDeviceSenderKey(payload.groupId, payload.sender);
+            if (!senderKey) {
+                throw new Error('missing sender key');
+            }
+            if (senderKey.keyId !== parsed.keyId) {
+                throw new Error('sender key id mismatch');
+            }
+            if (payload.keyId !== undefined &&
+                payload.keyId !== null &&
+                parsed.keyId !== payload.keyId) {
+                throw new Error('sender key id mismatch');
+            }
+            if (payload.iteration !== undefined &&
+                payload.iteration !== null &&
+                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');
+            }
+            const selected = await (0, SenderKeyChain_1.selectMessageKey)(senderKey, parsed.iteration);
+            // Keep decrypt + persist ordered: failed decrypt must not advance sender-key state.
+            const plaintext = await aesCbcDecryptFromSeed(selected.messageKey.seed, parsed.ciphertext);
+            await this.store.upsertSenderKey(selected.updatedRecord);
+            return plaintext;
+        });
     }
-    async ensureSenderKey(groupId, sender) {
+    async ensureSenderKeyInternal(groupId, sender) {
         const existing = await this.store.getDeviceSenderKey(groupId, sender);
         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: []
@@ -176,5 +202,8 @@ class SenderKeyManager {
         await this.store.upsertSenderKey(created);
         return created;
     }
+    runWithSenderLock(groupId, sender, task) {
+        return this.senderLock.run(`senderKey:${groupId}:${(0, jid_1.signalAddressKey)(sender)}`, task);
+    }
 }
 exports.SenderKeyManager = SenderKeyManager;

package/dist/signal/index.js

@@ -1,6 +1,18 @@
 "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 = exports.toSignalAddressParts = exports.encodeSignalSessionRecord = exports.encodeSenderKeyRecord = exports.decodeStoreCount = exports.decodeSenderKeyRecord = exports.decodeSenderKeyDistributionRow = exports.decodeSignalSignedPreKeyRow = exports.decodeSignalSessionRecord = exports.decodeSignalRemoteIdentity = exports.decodeSignalRegistrationRow = exports.decodeSignalPreKeyRow = void 0;
+var encoding_1 = require("./encoding");
+Object.defineProperty(exports, "decodeSignalPreKeyRow", { enumerable: true, get: function () { return encoding_1.decodeSignalPreKeyRow; } });
+Object.defineProperty(exports, "decodeSignalRegistrationRow", { enumerable: true, get: function () { return encoding_1.decodeSignalRegistrationRow; } });
+Object.defineProperty(exports, "decodeSignalRemoteIdentity", { enumerable: true, get: function () { return encoding_1.decodeSignalRemoteIdentity; } });
+Object.defineProperty(exports, "decodeSignalSessionRecord", { enumerable: true, get: function () { return encoding_1.decodeSignalSessionRecord; } });
+Object.defineProperty(exports, "decodeSignalSignedPreKeyRow", { enumerable: true, get: function () { return encoding_1.decodeSignalSignedPreKeyRow; } });
+Object.defineProperty(exports, "decodeSenderKeyDistributionRow", { enumerable: true, get: function () { return encoding_1.decodeSenderKeyDistributionRow; } });
+Object.defineProperty(exports, "decodeSenderKeyRecord", { enumerable: true, get: function () { return encoding_1.decodeSenderKeyRecord; } });
+Object.defineProperty(exports, "decodeStoreCount", { enumerable: true, get: function () { return encoding_1.decodeStoreCount; } });
+Object.defineProperty(exports, "encodeSenderKeyRecord", { enumerable: true, get: function () { return encoding_1.encodeSenderKeyRecord; } });
+Object.defineProperty(exports, "encodeSignalSessionRecord", { enumerable: true, get: function () { return encoding_1.encodeSignalSessionRecord; } });
+Object.defineProperty(exports, "toSignalAddressParts", { enumerable: true, get: function () { return encoding_1.toSignalAddressParts; } });
 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 +39,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/registration/keygen.js

@@ -9,9 +9,13 @@ const keys_1 = require("../../crypto/core/keys");
 const X25519_1 = require("../../crypto/curves/X25519");
 const WaAdvSignature_1 = require("../crypto/WaAdvSignature");
 async function generateRegistrationInfo() {
+    const [registrationId, identityKeyPair] = await Promise.all([
+        generateRegistrationId(),
+        X25519_1.X25519.generateKeyPair()
+    ]);
     return {
-        registrationId: await generateRegistrationId(),
-        identityKeyPair: await X25519_1.X25519.generateKeyPair()
+        registrationId,
+        identityKeyPair
     };
 }
 async function generatePreKeyPair(keyId) {

package/dist/signal/registration/utils.js

@@ -8,6 +8,7 @@ async function createAndStoreInitialKeys(store) {
         (0, keygen_1.generatePreKeyPair)(1)
     ]);
     const signedPreKey = await (0, keygen_1.generateSignedPreKey)(1, registrationInfo.identityKeyPair.privKey);
+    // Keep writes ordered so partial commit failures don't leave split registration bootstrap state.
     await store.setRegistrationInfo(registrationInfo);
     await store.setSignedPreKey(signedPreKey);
     await store.getOrGenSinglePreKey(async () => firstPreKey);

package/dist/signal/session/SignalProtocol.js

@@ -3,77 +3,187 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalProtocol = void 0;
 const _crypto_1 = require("../../crypto/index.js");
 const ConsoleLogger_1 = require("../../infra/log/ConsoleLogger");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
 const constants_1 = require("../constants");
 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}`;
+}
+function signalAddressLockKey(address) {
+    return `signal:${signalAddressMapKey(address)}`;
+}
 class SignalProtocol {
     constructor(store, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
         this.store = store;
         this.logger = logger;
+        this.sessionMutationLock = new StoreLock_1.StoreLock();
     }
-    async hasSession(address) {
-        return this.store.hasSession(address);
-    }
-    async hasSessions(addresses) {
-        return this.store.hasSessions(addresses);
+    async establishOutgoingSession(address, remoteBundle, options = {}) {
+        return this.runWithAddressLock(address, async () => {
+            if (options.reuseExisting) {
+                const existing = await this.store.getSession(address);
+                if (existing) {
+                    const remoteIdentity = (0, _crypto_1.toSerializedPubKey)(remoteBundle.identity);
+                    if (!(0, bytes_1.uint8Equal)(existing.remote.pubKey, remoteIdentity)) {
+                        throw new Error('identity mismatch');
+                    }
+                    return existing;
+                }
+            }
+            const [local, localOneTimeBase] = await Promise.all([
+                (0, SignalSession_1.requireLocalIdentity)(this.store),
+                (0, SignalSession_1.generateSerializedKeyPair)()
+            ]);
+            const session = await (0, SignalSession_1.initiateSessionOutgoing)(local, remoteBundle, localOneTimeBase);
+            // Keep writes ordered: a stored session without matching remote identity causes false mismatch checks.
+            await this.store.setRemoteIdentity(address, session.remote.pubKey);
+            await this.store.setSession(address, session);
+            return session;
+        });
     }
-    async establishOutgoingSession(address, remoteBundle) {
-        const [local, localOneTimeBase] = await Promise.all([
-            (0, SignalSession_1.requireLocalIdentity)(this.store),
-            (0, SignalSession_1.generateSerializedKeyPair)()
+    async encryptMessage(address, plaintext, expectedIdentity) {
+        const [encrypted] = await this.encryptMessagesBatch([
+            { address, plaintext, expectedIdentity }
         ]);
-        const session = await (0, SignalSession_1.initiateSessionOutgoing)(local, remoteBundle, localOneTimeBase);
-        await this.store.setRemoteIdentity(address, session.remote.pubKey);
-        await this.store.setSession(address, session);
-        return session;
+        return encrypted;
     }
-    async encryptMessage(address, plaintext, expectedIdentity) {
-        const session = await this.store.getSession(address);
-        if (!session) {
-            throw new Error('signal session not found');
-        }
-        if (expectedIdentity &&
-            !(0, bytes_1.uint8Equal)((0, _crypto_1.toSerializedPubKey)(expectedIdentity), session.remote.pubKey)) {
-            throw new Error('identity mismatch');
+    async encryptMessagesBatch(requests, prefetchedSessions) {
+        if (requests.length === 0) {
+            return [];
         }
-        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);
-        }
-        return {
-            ...encrypted,
-            baseKey: updatedSession.aliceBaseKey
-        };
+        const lockKeySet = new Set();
+        for (let i = 0; i < requests.length; i += 1)
+            lockKeySet.add(signalAddressLockKey(requests[i].address));
+        const lockKeys = [...lockKeySet];
+        return this.sessionMutationLock.runMany(lockKeys, async () => {
+            const prefetchedByAddress = new Map();
+            if (prefetchedSessions && prefetchedSessions.length > 0) {
+                for (let index = 0; index < prefetchedSessions.length; index += 1) {
+                    const entry = prefetchedSessions[index];
+                    prefetchedByAddress.set(signalAddressMapKey(entry.address), entry.session);
+                }
+            }
+            const uniqueAddressKeys = new Array(requests.length);
+            const uniqueAddresses = new Array(requests.length);
+            let uniqueAddressCount = 0;
+            for (let index = 0; index < requests.length; index += 1) {
+                const address = requests[index].address;
+                const addressKey = signalAddressMapKey(address);
+                let isDuplicate = false;
+                for (let dedupIndex = 0; dedupIndex < uniqueAddressCount; dedupIndex += 1) {
+                    if (uniqueAddressKeys[dedupIndex] === addressKey) {
+                        isDuplicate = true;
+                        break;
+                    }
+                }
+                if (isDuplicate) {
+                    continue;
+                }
+                uniqueAddressKeys[uniqueAddressCount] = addressKey;
+                uniqueAddresses[uniqueAddressCount] = address;
+                uniqueAddressCount += 1;
+            }
+            uniqueAddressKeys.length = uniqueAddressCount;
+            uniqueAddresses.length = uniqueAddressCount;
+            const currentSessions = await this.store.getSessionsBatch(uniqueAddresses);
+            const latestSessionByAddress = new Map();
+            for (let index = 0; index < uniqueAddressCount; index += 1) {
+                const addressKey = uniqueAddressKeys[index];
+                const current = currentSessions[index];
+                if (current) {
+                    latestSessionByAddress.set(addressKey, current);
+                    continue;
+                }
+                const prefetched = prefetchedByAddress.get(addressKey);
+                if (prefetched) {
+                    latestSessionByAddress.set(addressKey, prefetched);
+                }
+            }
+            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);
+                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
+                };
+            }
+            // Persist remote identities first when needed so session writes never commit ahead of identity data.
+            if (identityUpdatesByAddress.size > 0) {
+                const identityUpdates = new Array(identityUpdatesByAddress.size);
+                let identityIndex = 0;
+                for (const update of identityUpdatesByAddress.values()) {
+                    identityUpdates[identityIndex] = update;
+                    identityIndex += 1;
+                }
+                await this.store.setRemoteIdentities(identityUpdates);
+            }
+            const sessionUpdates = new Array(sessionUpdatesByAddress.size);
+            let sessionIndex = 0;
+            for (const update of sessionUpdatesByAddress.values()) {
+                sessionUpdates[sessionIndex] = update;
+                sessionIndex += 1;
+            }
+            await this.store.setSessionsBatch(sessionUpdates);
+            return results;
+        });
     }
     async decryptMessage(address, envelope) {
-        const currentSession = await this.store.getSession(address);
-        let outcome;
-        if (envelope.type === 'pkmsg') {
-            const parsedPk = (0, SignalSerializer_1.deserializePkMsg)(envelope.ciphertext);
-            outcome = await this.decryptPkMsg(currentSession, parsedPk);
-        }
-        else {
-            const parsed = (0, SignalSerializer_1.deserializeMsg)(envelope.ciphertext);
-            outcome = await this.decryptMsgInternal(currentSession, parsed);
-        }
-        const nextRemoteIdentity = outcome.newSessionInfo?.newIdentity ?? outcome.updatedSession.remote.pubKey;
-        if (!currentSession || !(0, bytes_1.uint8Equal)(currentSession.remote.pubKey, nextRemoteIdentity)) {
-            await this.store.setRemoteIdentity(address, nextRemoteIdentity);
-        }
-        await this.store.setSession(address, outcome.updatedSession);
-        return outcome.plaintext;
-    }
-    async decryptMsgInternal(session, parsed) {
-        return (0, SignalRatchet_1.decryptMsg)(session, parsed, (error, previousSessionIndex) => {
-            this.logger.debug('signal decrypt fallback session failed', {
-                previousSessionIndex,
-                message: error.message
-            });
+        return this.runWithAddressLock(address, async () => {
+            const currentSession = await this.store.getSession(address);
+            let outcome;
+            if (envelope.type === 'pkmsg') {
+                const parsedPk = (0, SignalSerializer_1.deserializePkMsg)(envelope.ciphertext);
+                outcome = await this.decryptPkMsg(currentSession, parsedPk);
+            }
+            else {
+                const parsed = (0, SignalSerializer_1.deserializeMsg)(envelope.ciphertext);
+                outcome = await (0, SignalRatchet_1.decryptMsg)(currentSession, parsed, (error, previousSessionIndex) => {
+                    this.logger.debug('signal decrypt fallback session failed', {
+                        previousSessionIndex,
+                        message: error.message
+                    });
+                });
+            }
+            const nextRemoteIdentity = outcome.newSessionInfo?.newIdentity ?? outcome.updatedSession.remote.pubKey;
+            const identityChanged = !currentSession || !(0, bytes_1.uint8Equal)(currentSession.remote.pubKey, nextRemoteIdentity);
+            // Keep writes ordered for consistency with resolver identity checks.
+            if (identityChanged) {
+                await this.store.setRemoteIdentity(address, nextRemoteIdentity);
+            }
+            await this.store.setSession(address, outcome.updatedSession);
+            return outcome.plaintext;
         });
     }
+    runWithAddressLock(address, task) {
+        return this.sessionMutationLock.run(signalAddressLockKey(address), task);
+    }
     async decryptPkMsg(currentSession, parsed) {
         const matchingSession = (0, SignalSession_1.findMatchingSession)(currentSession, parsed.sessionBaseKey);
         if (matchingSession) {
@@ -109,6 +219,7 @@ class SignalProtocol {
             }
             : incoming;
         const [updatedSession, plaintext] = await (0, SignalRatchet_1.decryptMsgFromSession)(baseSession, parsed);
+        // Only consume one-time prekeys after successful decrypt/session materialization.
         if (parsed.localOneTimeKeyId !== null && parsed.localOneTimeKeyId !== undefined) {
             await this.store.consumePreKeyById(parsed.localOneTimeKeyId);
         }