zapo-js 0.1.1 → 0.2.0

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

@@ -1,6 +1,9 @@
 import { aesCbcDecrypt, aesCbcEncrypt, importAesCbcKey, toSerializedPubKey, prependVersion, randomBytesAsync, randomIntAsync, X25519 } from '../../crypto/index.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
 import { proto } from '../../proto.js';
-import { SIGNAL_GROUP_VERSION, SIGNATURE_SIZE } from '../constants.js';
+import { signalAddressKey } from '../../protocol/jid.js';
+import { SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
+import { SIGNAL_GROUP_VERSION } from '../constants.js';
 import { signSignalMessage, verifySignalSignature } from '../crypto/WaAdvSignature.js';
 import { deriveSenderKeyMsgKey, selectMessageKey } from '../group/SenderKeyChain.js';
 import { parseDistributionPayload, parseSenderKeyMessage } from '../group/SenderKeyCodec.js';
@@ -24,148 +27,171 @@ async function aesCbcDecryptFromSeed(seed, ciphertext) {
 }
 export class SenderKeyManager {
     constructor(store) {
+        this.senderLock = new StoreLock();
         this.store = store;
     }
-    async createSenderKeyDistributionMessage(groupId, sender) {
-        const senderKey = await this.ensureSenderKey(groupId, sender);
-        const distributionProto = proto.SenderKeyDistributionMessage.encode({
-            id: senderKey.keyId,
-            iteration: senderKey.iteration,
-            chainKey: senderKey.chainKey,
-            signingKey: senderKey.signingPublicKey
-        }).finish();
-        const payload = prependVersion(distributionProto, 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 deriveSenderKeyMsgKey(senderKey.iteration, senderKey.chainKey);
+            await this.store.upsertSenderKey({
+                ...senderKey,
+                chainKey: derived.nextChainKey,
+                iteration: derived.messageKey.iteration + 1
+            });
+            const distributionProto = proto.SenderKeyDistributionMessage.encode({
+                id: senderKey.keyId,
+                iteration: senderKey.iteration,
+                chainKey: senderKey.chainKey,
+                signingKey: senderKey.signingPublicKey
+            }).finish();
+            const distributionMessage = {
+                groupId,
+                axolotlSenderKeyDistributionMessage: prependVersion(distributionProto, SIGNAL_GROUP_VERSION)
+            };
+            const messagePayload = await aesCbcEncryptFromSeed(derived.messageKey.seed, plaintext);
+            const senderKeyMessage = proto.SenderKeyMessage.encode({
+                id: senderKey.keyId,
+                iteration: derived.messageKey.iteration,
+                ciphertext: messagePayload
+            }).finish();
+            const versionedContent = prependVersion(senderKeyMessage, SIGNAL_GROUP_VERSION);
+            const signature = await signSignalMessage(senderKey.signingPrivateKey, versionedContent);
+            if (signature.length !== 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: 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 = 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 deriveSenderKeyMsgKey(senderKey.iteration, senderKey.chainKey);
-        const messagePayload = await aesCbcEncryptFromSeed(derived.messageKey.seed, plaintext);
-        const senderKeyMessage = proto.SenderKeyMessage.encode({
-            id: senderKey.keyId,
-            iteration: derived.messageKey.iteration,
-            ciphertext: messagePayload
-        }).finish();
-        const versionedContent = prependVersion(senderKeyMessage, SIGNAL_GROUP_VERSION);
-        const signature = await signSignalMessage(senderKey.signingPrivateKey, versionedContent);
-        if (signature.length !== SIGNATURE_SIZE) {
-            throw new Error(`invalid sender key signature length ${signature.length}`);
-        }
-        const ciphertext = 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 = 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 = 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 - SIGNATURE_SIZE);
-        const signature = parsed.versionContentMac.subarray(parsed.versionContentMac.length - SIGNATURE_SIZE);
-        const validSignature = await verifySignalSignature(senderKey.signingPublicKey, signedContent, signature);
-        if (!validSignature) {
-            throw new Error('invalid sender key signature');
-        }
-        const selected = await 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 = 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 - SIGNAL_SIGNATURE_LENGTH);
+            const signature = parsed.versionContentMac.subarray(parsed.versionContentMac.length - SIGNAL_SIGNATURE_LENGTH);
+            const validSignature = await verifySignalSignature(senderKey.signingPublicKey, signedContent, signature);
+            if (!validSignature) {
+                throw new Error('invalid sender key signature');
+            }
+            const selected = await 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 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: []
@@ -173,4 +199,7 @@ export class SenderKeyManager {
         await this.store.upsertSenderKey(created);
         return created;
     }
+    runWithSenderLock(groupId, sender, task) {
+        return this.senderLock.run(`senderKey:${groupId}:${signalAddressKey(sender)}`, task);
+    }
 }

package/dist/esm/signal/index.js

@@ -1,3 +1,4 @@
+export { decodeSignalPreKeyRow, decodeSignalRegistrationRow, decodeSignalRemoteIdentity, decodeSignalSessionRecord, decodeSignalSignedPreKeyRow, decodeSenderKeyDistributionRow, decodeSenderKeyRecord, decodeStoreCount, encodeSenderKeyRecord, encodeSignalSessionRecord, toSignalAddressParts } from './encoding.js';
 export { generatePreKeyPair, generateRegistrationId, generateRegistrationInfo, generateSignedPreKey } from './registration/keygen.js';
 export { buildPreKeyUploadIq, parsePreKeyUploadFailure } from './api/prekeys.js';
 export { SignalDigestSyncApi } from './api/SignalDigestSyncApi.js';
@@ -9,3 +10,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/registration/keygen.js

@@ -3,9 +3,13 @@ import { toSerializedPubKey } from '../../crypto/core/keys.js';
 import { X25519 } from '../../crypto/curves/X25519.js';
 import { signSignalMessage } from '../crypto/WaAdvSignature.js';
 export async function generateRegistrationInfo() {
+    const [registrationId, identityKeyPair] = await Promise.all([
+        generateRegistrationId(),
+        X25519.generateKeyPair()
+    ]);
     return {
-        registrationId: await generateRegistrationId(),
-        identityKeyPair: await X25519.generateKeyPair()
+        registrationId,
+        identityKeyPair
     };
 }
 export async function generatePreKeyPair(keyId) {

package/dist/esm/signal/registration/utils.js

@@ -5,6 +5,7 @@ export async function createAndStoreInitialKeys(store) {
         generatePreKeyPair(1)
     ]);
     const signedPreKey = await 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/esm/signal/session/SignalProtocol.js

@@ -1,76 +1,186 @@
 import { toSerializedPubKey } from '../../crypto/index.js';
 import { ConsoleLogger } from '../../infra/log/ConsoleLogger.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
 import { MAX_PREV_SESSIONS } from '../constants.js';
 import { decryptMsg, decryptMsgFromSession, encryptMsg } from '../session/SignalRatchet.js';
 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}`;
+}
+function signalAddressLockKey(address) {
+    return `signal:${signalAddressMapKey(address)}`;
+}
 export class SignalProtocol {
     constructor(store, logger = new ConsoleLogger('info')) {
         this.store = store;
         this.logger = logger;
+        this.sessionMutationLock = new 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 = toSerializedPubKey(remoteBundle.identity);
+                    if (!uint8Equal(existing.remote.pubKey, remoteIdentity)) {
+                        throw new Error('identity mismatch');
+                    }
+                    return existing;
+                }
+            }
+            const [local, localOneTimeBase] = await Promise.all([
+                requireLocalIdentity(this.store),
+                generateSerializedKeyPair()
+            ]);
+            const session = await 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([
-            requireLocalIdentity(this.store),
-            generateSerializedKeyPair()
+    async encryptMessage(address, plaintext, expectedIdentity) {
+        const [encrypted] = await this.encryptMessagesBatch([
+            { address, plaintext, expectedIdentity }
         ]);
-        const session = await 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 &&
-            !uint8Equal(toSerializedPubKey(expectedIdentity), session.remote.pubKey)) {
-            throw new Error('identity mismatch');
+    async encryptMessagesBatch(requests, prefetchedSessions) {
+        if (requests.length === 0) {
+            return [];
         }
-        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);
-        }
-        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 &&
+                    !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
+                };
+            }
+            // 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 = deserializePkMsg(envelope.ciphertext);
-            outcome = await this.decryptPkMsg(currentSession, parsedPk);
-        }
-        else {
-            const parsed = deserializeMsg(envelope.ciphertext);
-            outcome = await this.decryptMsgInternal(currentSession, parsed);
-        }
-        const nextRemoteIdentity = outcome.newSessionInfo?.newIdentity ?? outcome.updatedSession.remote.pubKey;
-        if (!currentSession || !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 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 = deserializePkMsg(envelope.ciphertext);
+                outcome = await this.decryptPkMsg(currentSession, parsedPk);
+            }
+            else {
+                const parsed = deserializeMsg(envelope.ciphertext);
+                outcome = await 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 || !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 = findMatchingSession(currentSession, parsed.sessionBaseKey);
         if (matchingSession) {
@@ -106,6 +216,7 @@ export class SignalProtocol {
             }
             : incoming;
         const [updatedSession, plaintext] = await 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);
         }

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,