zapo-js 0.2.0 → 0.3.0

package/dist/esm/signal/encoding.js

@@ -46,7 +46,7 @@ export function decodeSignalSignedPreKeyRow(row) {
         uploaded: toBoolOrUndef(row.uploaded)
     };
 }
-function encodeSignalSessionSnapshot(session) {
+export function encodeSignalSessionSnapshot(session) {
     return {
         sessionVersion: 3,
         localRegistrationId: session.local.regId,
@@ -56,13 +56,7 @@ function encodeSignalSessionSnapshot(session) {
         rootKey: session.rootKey,
         previousCounter: session.prevSendChainHighestIndex,
         senderChain: encodeSignalSendChain(session.sendChain),
-        receiverChains: (() => {
-            const src = session.recvChains;
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = encodeSignalRecvChain(src[i]);
-            return arr;
-        })(),
+        receiverChains: session.recvChains,
         pendingPreKey: session.initialExchangeInfo
             ? {
                 preKeyId: session.initialExchangeInfo.remoteOneTimeId ?? undefined,
@@ -84,30 +78,17 @@ function encodeSignalSendChain(chain) {
         messageKeys: []
     };
 }
-function encodeSignalRecvChain(chain) {
+export function encodeSignalRecvChain(chain) {
     return {
         senderRatchetKey: chain.ratchetPubKey,
         chainKey: {
             index: chain.nextMsgIndex,
             key: chain.chainKey
         },
-        messageKeys: (() => {
-            const src = chain.unusedMsgKeys ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1) {
-                const messageKey = src[i];
-                arr[i] = {
-                    index: messageKey.index,
-                    cipherKey: messageKey.cipherKey,
-                    macKey: messageKey.macKey,
-                    iv: messageKey.iv
-                };
-            }
-            return arr;
-        })()
+        messageKeys: chain.unusedMsgKeys
     };
 }
-function decodeSignalMessageKey(messageKey, field) {
+export function decodeSignalMessageKey(messageKey, field) {
     const cipherKey = asBytes(messageKey.cipherKey, `${field}.cipherKey`);
     assertByteLength(cipherKey, 32, `invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
     const macKey = asBytes(messageKey.macKey, `${field}.macKey`);
@@ -121,7 +102,7 @@ function decodeSignalMessageKey(messageKey, field) {
         iv
     };
 }
-function decodeSignalRecvChain(chain, field) {
+export function decodeSignalRecvChain(chain, field) {
     const chainKey = chain.chainKey;
     if (!chainKey) {
         throw new Error(`missing ${field}.chainKey`);
@@ -134,13 +115,7 @@ function decodeSignalRecvChain(chain, field) {
         ratchetPubKey,
         nextMsgIndex: asNumber(chainKey.index, `${field}.chainKey.index`),
         chainKey: chainKeyBytes,
-        unusedMsgKeys: (() => {
-            const src = chain.messageKeys ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = decodeSignalMessageKey(src[i], `${field}.messageKeys[${i}]`);
-            return arr;
-        })()
+        unusedMsgKeys: chain.messageKeys ?? []
     };
 }
 function decodeSignalSendChain(chain, field) {
@@ -166,7 +141,7 @@ function decodeSignalSendChain(chain, field) {
         chainKey: chainKeyBytes
     };
 }
-function decodeSignalSessionSnapshot(session, field) {
+export function decodeSignalSessionSnapshot(session, field) {
     const senderChain = session.senderChain;
     if (!senderChain) {
         throw new Error(`missing ${field}.senderChain`);
@@ -199,13 +174,7 @@ function decodeSignalSessionSnapshot(session, field) {
         },
         rootKey,
         sendChain: decodeSignalSendChain(senderChain, `${field}.senderChain`),
-        recvChains: (() => {
-            const src = session.receiverChains ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = decodeSignalRecvChain(src[i], `${field}.receiverChains[${i}]`);
-            return arr;
-        })(),
+        recvChains: session.receiverChains ?? [],
         initialExchangeInfo: pendingPreKey
             ? {
                 remoteOneTimeId: asOptionalNumber(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
@@ -221,13 +190,7 @@ function decodeSignalSessionSnapshot(session, field) {
 export function encodeSignalSessionRecord(record) {
     return proto.RecordStructure.encode({
         currentSession: encodeSignalSessionSnapshot(record),
-        previousSessions: (() => {
-            const src = record.prevSessions;
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = encodeSignalSessionSnapshot(src[i]);
-            return arr;
-        })()
+        previousSessions: record.prevSessions
     }).finish();
 }
 export function decodeSignalSessionRecord(raw) {
@@ -238,13 +201,7 @@ export function decodeSignalSessionRecord(raw) {
     const current = decodeSignalSessionSnapshot(decoded.currentSession, 'signal_sessions.currentSession');
     return {
         ...current,
-        prevSessions: (() => {
-            const src = decoded.previousSessions ?? [];
-            const arr = new Array(src.length);
-            for (let i = 0; i < src.length; i += 1)
-                arr[i] = decodeSignalSessionSnapshot(src[i], `signal_sessions.previousSessions[${i}]`);
-            return arr;
-        })()
+        prevSessions: decoded.previousSessions ?? []
     };
 }
 export function encodeSenderKeyRecord(record) {

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

@@ -1,9 +1,9 @@
-import { hkdf, importHmacKey, hmacSign } from '../../crypto/index.js';
+import { hkdf, hmacSign, importHmacKey } 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 { assertByteLength, removeAt } from '../../util/bytes.js';
-export async function selectMessageKey(senderKey, targetIteration) {
+export async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
     const delta = targetIteration - senderKey.iteration;
-    if (delta > SENDER_KEY_FUTURE_MESSAGES_MAX) {
+    if (delta > (futureMessagesMax ?? SENDER_KEY_FUTURE_MESSAGES_MAX)) {
         throw new Error('sender key message is too far in future');
     }
     const currentUnused = senderKey.unusedMessageKeys ?? [];

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

@@ -2,7 +2,7 @@ import { readVersionedContent, toSerializedPubKey } from '../../crypto/index.js'
 import { proto } from '../../proto.js';
 import { SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
 import { SIGNAL_GROUP_VERSION } from '../constants.js';
-import { assertByteLength, toBytesView } from '../../util/bytes.js';
+import { assertByteLength } from '../../util/bytes.js';
 export function parseDistributionPayload(payload) {
     const body = readVersionedContent(payload, SIGNAL_GROUP_VERSION, 0);
     const decoded = proto.SenderKeyDistributionMessage.decode(body);
@@ -16,13 +16,12 @@ export function parseDistributionPayload(payload) {
         decoded.signingKey === undefined) {
         throw new Error('invalid sender key distribution message');
     }
-    const chainKey = toBytesView(decoded.chainKey);
-    assertByteLength(chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
+    assertByteLength(decoded.chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,
-        chainKey,
-        signingPublicKey: toSerializedPubKey(toBytesView(decoded.signingKey))
+        chainKey: decoded.chainKey,
+        signingPublicKey: toSerializedPubKey(decoded.signingKey)
     };
 }
 export function parseSenderKeyMessage(versionContentMac) {
@@ -39,7 +38,7 @@ export function parseSenderKeyMessage(versionContentMac) {
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,
-        ciphertext: toBytesView(decoded.ciphertext),
+        ciphertext: decoded.ciphertext,
         versionContentMac
     };
 }

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

@@ -1,10 +1,9 @@
-import { aesCbcDecrypt, aesCbcEncrypt, importAesCbcKey, toSerializedPubKey, prependVersion, randomBytesAsync, randomIntAsync, X25519 } from '../../crypto/index.js';
+import { aesCbcDecrypt, aesCbcEncrypt, importAesCbcKey, prependVersion, randomBytesAsync, randomIntAsync, toRawPubKey, toSerializedPubKey, X25519, xeddsaSign, xeddsaVerify } from '../../crypto/index.js';
 import { StoreLock } from '../../infra/perf/StoreLock.js';
 import { proto } from '../../proto.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';
 import { concatBytes } from '../../util/bytes.js';
@@ -26,9 +25,11 @@ async function aesCbcDecryptFromSeed(seed, ciphertext) {
     return aesCbcDecrypt(await importAesCbcKey(keyBytes), iv, ciphertext);
 }
 export class SenderKeyManager {
-    constructor(store) {
+    constructor(store, options) {
         this.senderLock = new StoreLock();
         this.store = store;
+        this.getFutureMessagesMax = options?.getFutureMessagesMax;
+        this.skipSignatureVerification = options?.skipSignatureVerification === true;
     }
     async prepareGroupEncryption(groupId, sender, plaintext) {
         return this.runWithSenderLock(groupId, sender, async () => {
@@ -59,7 +60,7 @@ export class SenderKeyManager {
                 ciphertext: messagePayload
             }).finish();
             const versionedContent = prependVersion(senderKeyMessage, SIGNAL_GROUP_VERSION);
-            const signature = await signSignalMessage(senderKey.signingPrivateKey, versionedContent);
+            const signature = await xeddsaSign(senderKey.signingPrivateKey, versionedContent);
             if (signature.length !== SIGNAL_SIGNATURE_LENGTH) {
                 throw new Error(`invalid sender key signature length ${signature.length}`);
             }
@@ -163,13 +164,15 @@ export class SenderKeyManager {
                 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');
+            if (!this.skipSignatureVerification) {
+                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 xeddsaVerify(toRawPubKey(senderKey.signingPublicKey), signedContent, signature);
+                if (!validSignature) {
+                    throw new Error('invalid sender key signature');
+                }
             }
-            const selected = await selectMessageKey(senderKey, parsed.iteration);
+            const selected = await selectMessageKey(senderKey, parsed.iteration, this.getFutureMessagesMax?.());
             // Keep decrypt + persist ordered: failed decrypt must not advance sender-key state.
             const plaintext = await aesCbcDecryptFromSeed(selected.messageKey.seed, parsed.ciphertext);
             await this.store.upsertSenderKey(selected.updatedRecord);

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

@@ -1,7 +1,6 @@
-import { randomIntAsync } from '../../crypto/index.js';
+import { randomIntAsync, xeddsaSign } from '../../crypto/index.js';
 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(),
@@ -22,7 +21,7 @@ export async function generatePreKeyPair(keyId) {
 export async function generateSignedPreKey(keyId, signingPrivateKey) {
     const keyPair = await X25519.generateKeyPair();
     const serializedPubKey = toSerializedPubKey(keyPair.pubKey);
-    const signature = await signSignalMessage(signingPrivateKey, serializedPubKey);
+    const signature = await xeddsaSign(signingPrivateKey, serializedPubKey);
     return {
         keyId,
         keyPair,

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

@@ -1,5 +1,5 @@
 import { generatePreKeyPair, generateRegistrationInfo, generateSignedPreKey } from '../registration/keygen.js';
-export async function createAndStoreInitialKeys(store) {
+export async function createAndStoreInitialKeys(store, preKeyStore) {
     const [registrationInfo, firstPreKey] = await Promise.all([
         generateRegistrationInfo(),
         generatePreKeyPair(1)
@@ -8,7 +8,7 @@ export async function createAndStoreInitialKeys(store) {
     // 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);
+    await preKeyStore.getOrGenSinglePreKey(async () => firstPreKey);
     return {
         registrationInfo,
         signedPreKey,

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

@@ -2,6 +2,7 @@ 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 { encodeSignalSessionSnapshot } from '../encoding.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';
@@ -13,15 +14,15 @@ function signalAddressLockKey(address) {
     return `signal:${signalAddressMapKey(address)}`;
 }
 export class SignalProtocol {
-    constructor(store, logger = new ConsoleLogger('info')) {
-        this.store = store;
+    constructor(stores, logger = new ConsoleLogger('info')) {
+        this.stores = stores;
         this.logger = logger;
         this.sessionMutationLock = new StoreLock();
     }
     async establishOutgoingSession(address, remoteBundle, options = {}) {
         return this.runWithAddressLock(address, async () => {
             if (options.reuseExisting) {
-                const existing = await this.store.getSession(address);
+                const existing = await this.stores.session.getSession(address);
                 if (existing) {
                     const remoteIdentity = toSerializedPubKey(remoteBundle.identity);
                     if (!uint8Equal(existing.remote.pubKey, remoteIdentity)) {
@@ -31,13 +32,13 @@ export class SignalProtocol {
                 }
             }
             const [local, localOneTimeBase] = await Promise.all([
-                requireLocalIdentity(this.store),
+                requireLocalIdentity(this.stores.signal),
                 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);
+            await this.stores.identity.setRemoteIdentity(address, session.remote.pubKey);
+            await this.stores.session.setSession(address, session);
             return session;
         });
     }
@@ -85,7 +86,7 @@ export class SignalProtocol {
             }
             uniqueAddressKeys.length = uniqueAddressCount;
             uniqueAddresses.length = uniqueAddressCount;
-            const currentSessions = await this.store.getSessionsBatch(uniqueAddresses);
+            const currentSessions = await this.stores.session.getSessionsBatch(uniqueAddresses);
             const latestSessionByAddress = new Map();
             for (let index = 0; index < uniqueAddressCount; index += 1) {
                 const addressKey = uniqueAddressKeys[index];
@@ -139,7 +140,7 @@ export class SignalProtocol {
                     identityUpdates[identityIndex] = update;
                     identityIndex += 1;
                 }
-                await this.store.setRemoteIdentities(identityUpdates);
+                await this.stores.identity.setRemoteIdentities(identityUpdates);
             }
             const sessionUpdates = new Array(sessionUpdatesByAddress.size);
             let sessionIndex = 0;
@@ -147,13 +148,13 @@ export class SignalProtocol {
                 sessionUpdates[sessionIndex] = update;
                 sessionIndex += 1;
             }
-            await this.store.setSessionsBatch(sessionUpdates);
+            await this.stores.session.setSessionsBatch(sessionUpdates);
             return results;
         });
     }
     async decryptMessage(address, envelope) {
         return this.runWithAddressLock(address, async () => {
-            const currentSession = await this.store.getSession(address);
+            const currentSession = await this.stores.session.getSession(address);
             let outcome;
             if (envelope.type === 'pkmsg') {
                 const parsedPk = deserializePkMsg(envelope.ciphertext);
@@ -172,9 +173,9 @@ export class SignalProtocol {
             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.stores.identity.setRemoteIdentity(address, nextRemoteIdentity);
             }
-            await this.store.setSession(address, outcome.updatedSession);
+            await this.stores.session.setSession(address, outcome.updatedSession);
             return outcome.plaintext;
         });
     }
@@ -192,11 +193,11 @@ export class SignalProtocol {
             };
         }
         const [local, signedPreKey, oneTimePreKey] = await Promise.all([
-            requireLocalIdentity(this.store),
-            requireSignedPreKey(this.store, parsed.localSignedPreKeyId),
+            requireLocalIdentity(this.stores.signal),
+            requireSignedPreKey(this.stores.signal, parsed.localSignedPreKeyId),
             parsed.localOneTimeKeyId === null || parsed.localOneTimeKeyId === undefined
                 ? Promise.resolve(null)
-                : requirePreKey(this.store, parsed.localOneTimeKeyId)
+                : requirePreKey(this.stores.preKey, parsed.localOneTimeKeyId)
         ]);
         const incoming = await initiateSessionIncoming(local, parsed.remote, parsed.sessionBaseKey, {
             signed: toSerializedKeyPair(signedPreKey.keyPair),
@@ -210,7 +211,7 @@ export class SignalProtocol {
             ? {
                 ...incoming,
                 prevSessions: [
-                    detachSession(currentSession),
+                    encodeSignalSessionSnapshot(detachSession(currentSession)),
                     ...currentSession.prevSessions.slice(0, MAX_PREV_SESSIONS - 1)
                 ]
             }
@@ -218,7 +219,7 @@ export class SignalProtocol {
         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);
+            await this.stores.preKey.consumePreKeyById(parsed.localOneTimeKeyId);
         }
         return {
             updatedSession,

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

@@ -1,7 +1,8 @@
-import { aesCbcDecrypt, aesCbcEncrypt, hkdf, importAesCbcKey, importHmacKey, hmacSign, prependVersion, toSerializedPubKey } from '../../crypto/index.js';
+import { aesCbcDecrypt, aesCbcEncrypt, hkdf, hmacSign, importAesCbcKey, importHmacKey, prependVersion, toSerializedPubKey } from '../../crypto/index.js';
 import { proto } from '../../proto.js';
 import { CHAIN_KEY_LABEL, FUTURE_MESSAGES_MAX, MAX_UNUSED_KEYS, MESSAGE_KEY_LABEL, SIGNAL_MAC_SIZE, SIGNAL_VERSION } from '../constants.js';
-import { detachSession, calculateRatchet, generateSerializedKeyPair, snapshotToRecord } from '../session/SignalSession.js';
+import { decodeSignalMessageKey, decodeSignalRecvChain, decodeSignalSessionSnapshot, encodeSignalRecvChain, encodeSignalSessionSnapshot } from '../encoding.js';
+import { calculateRatchet, detachSession, generateSerializedKeyPair, snapshotToRecord } from '../session/SignalSession.js';
 import { concatBytes, removeAt, uint8Equal } from '../../util/bytes.js';
 import { toError } from '../../util/primitives.js';
 const MAX_TRACKED_RECV_CHAINS = 4;
@@ -35,7 +36,7 @@ export async function selectMessageKey(chain, targetCounter) {
         if (idx === -1) {
             throw new Error('duplicate message');
         }
-        const messageKey = unused[idx];
+        const messageKey = decodeSignalMessageKey(unused[idx], `unusedMsgKeys[${idx}]`);
         const nextUnused = removeAt(unused, idx);
         return {
             messageKey,
@@ -73,7 +74,12 @@ export async function selectMessageKey(chain, targetCounter) {
             overflow -= 1;
         }
         else {
-            nextUnused.push(currentMessageKey);
+            nextUnused.push({
+                index: currentMessageKey.index,
+                cipherKey: currentMessageKey.cipherKey,
+                macKey: currentMessageKey.macKey,
+                iv: currentMessageKey.iv
+            });
         }
         const derived = await deriveMsgKeyFromState(counter, chainState);
         currentMessageKey = derived.messageKey;
@@ -174,13 +180,14 @@ export async function decryptMsg(session, parsed, onPrevSessionDecryptError) {
     }
     catch (error) {
         for (let i = 0; i < session.prevSessions.length; i += 1) {
-            const prevSession = snapshotToRecord(session.prevSessions[i]);
+            const decodedPrev = decodeSignalSessionSnapshot(session.prevSessions[i], `prevSessions[${i}]`);
+            const prevSession = snapshotToRecord(decodedPrev);
             try {
                 const [updatedPrev, plaintext] = await decryptMsgFromSession(prevSession, parsed);
                 const updatedSession = {
                     ...updatedPrev,
                     prevSessions: [
-                        detachSession(session),
+                        encodeSignalSessionSnapshot(detachSession(session)),
                         ...session.prevSessions.slice(0, i),
                         ...session.prevSessions.slice(i + 1)
                     ]
@@ -207,7 +214,10 @@ export async function decryptMsg(session, parsed, onPrevSessionDecryptError) {
 }
 export async function decryptMsgFromSession(session, message) {
     const ratchetPubKey = toSerializedPubKey(message.ratchetPubKey);
-    const recvChainIndex = session.recvChains.findIndex((entry) => uint8Equal(entry.ratchetPubKey, ratchetPubKey));
+    const recvChainIndex = session.recvChains.findIndex((raw) => {
+        const key = raw.senderRatchetKey;
+        return key !== null && key !== undefined && uint8Equal(key, ratchetPubKey);
+    });
     let selectedMessageKey;
     let updatedSession;
     if (recvChainIndex === -1) {
@@ -225,7 +235,7 @@ export async function decryptMsgFromSession(session, message) {
         selectedMessageKey = selected.messageKey;
         const sendRatchet = await calculateRatchet(recvRatchet.rootKey, newSendRatchet, ratchetPubKey);
         const nextRecvChains = session.recvChains.slice(-MAX_TRACKED_RECV_CHAINS);
-        nextRecvChains.push(selected.updatedChain);
+        nextRecvChains.push(encodeSignalRecvChain(selected.updatedChain));
         updatedSession = {
             ...session,
             rootKey: sendRatchet.rootKey,
@@ -240,10 +250,11 @@ export async function decryptMsgFromSession(session, message) {
         };
     }
     else {
-        const selected = await selectMessageKey(session.recvChains[recvChainIndex], message.counter);
+        const decoded = decodeSignalRecvChain(session.recvChains[recvChainIndex], `recvChains[${recvChainIndex}]`);
+        const selected = await selectMessageKey(decoded, message.counter);
         selectedMessageKey = selected.messageKey;
         const nextRecvChains = session.recvChains.slice();
-        nextRecvChains[recvChainIndex] = selected.updatedChain;
+        nextRecvChains[recvChainIndex] = encodeSignalRecvChain(selected.updatedChain);
         updatedSession = {
             ...session,
             recvChains: nextRecvChains

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

@@ -1,7 +1,6 @@
 import { readVersionedContent, toSerializedPubKey } from '../../crypto/index.js';
 import { proto } from '../../proto.js';
 import { SIGNAL_MAC_SIZE, SIGNAL_VERSION } from '../constants.js';
-import { toBytesView } from '../../util/bytes.js';
 export function deserializeMsg(versionContentMac) {
     const content = readVersionedContent(versionContentMac, SIGNAL_VERSION, SIGNAL_MAC_SIZE);
     const parsed = proto.SignalMessage.decode(content);
@@ -14,9 +13,9 @@ export function deserializeMsg(versionContentMac) {
         throw new Error('invalid signal message');
     }
     return {
-        ratchetPubKey: toSerializedPubKey(toBytesView(parsed.ratchetKey)),
+        ratchetPubKey: toSerializedPubKey(parsed.ratchetKey),
         counter: parsed.counter,
-        ciphertext: toBytesView(parsed.ciphertext),
+        ciphertext: parsed.ciphertext,
         versionContentMac
     };
 }
@@ -35,14 +34,14 @@ export function deserializePkMsg(versionContent) {
         parsed.message === undefined) {
         throw new Error('invalid prekey signal message');
     }
-    const signal = deserializeMsg(toBytesView(parsed.message));
+    const signal = deserializeMsg(parsed.message);
     return {
         ...signal,
         remote: {
             regId: parsed.registrationId,
-            pubKey: toSerializedPubKey(toBytesView(parsed.identityKey))
+            pubKey: toSerializedPubKey(parsed.identityKey)
         },
-        sessionBaseKey: toSerializedPubKey(toBytesView(parsed.baseKey)),
+        sessionBaseKey: toSerializedPubKey(parsed.baseKey),
         localSignedPreKeyId: parsed.signedPreKeyId,
         localOneTimeKeyId: parsed.preKeyId ?? null
     };

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

@@ -1,5 +1,6 @@
 import { hkdfSplit, toRawPubKey, toSerializedPubKey, X25519 } from '../../crypto/index.js';
 import { SIGNAL_PREFIX } from '../constants.js';
+import { decodeSignalSessionSnapshot, encodeSignalSessionSnapshot } from '../encoding.js';
 import { concatBytes, uint8Equal } from '../../util/bytes.js';
 export function snapshotToRecord(snapshot) {
     return {
@@ -21,19 +22,21 @@ export function findMatchingSession(session, sessionBaseKey) {
         return session;
     }
     for (let index = 0; index < session.prevSessions.length; index += 1) {
-        const previousSession = session.prevSessions[index];
-        if (!previousSession.aliceBaseKey ||
-            !uint8Equal(previousSession.aliceBaseKey, serializedBaseKey)) {
+        const rawPrev = session.prevSessions[index];
+        if (!rawPrev.aliceBaseKey || !uint8Equal(rawPrev.aliceBaseKey, serializedBaseKey)) {
             continue;
         }
-        const prevSessions = [detachSession(session)];
+        const decoded = decodeSignalSessionSnapshot(rawPrev, `prevSessions[${index}]`);
+        const prevSessions = [
+            encodeSignalSessionSnapshot(detachSession(session))
+        ];
         for (let i = 0; i < session.prevSessions.length; i += 1) {
             if (i !== index) {
                 prevSessions.push(session.prevSessions[i]);
             }
         }
         return {
-            ...previousSession,
+            ...decoded,
             prevSessions
         };
     }
@@ -73,10 +76,9 @@ export async function initiateSessionOutgoing(local, remoteBundle, localOneTimeB
     ]);
     const [rootKey, chainKey] = await hkdfSplit(secret, null, 'WhisperText');
     const recvChain = {
-        ratchetPubKey: remoteRatchetKey,
-        nextMsgIndex: 0,
-        chainKey,
-        unusedMsgKeys: []
+        senderRatchetKey: remoteRatchetKey,
+        chainKey: { index: 0, key: chainKey },
+        messageKeys: []
     };
     const sendRatchet = await generateSerializedKeyPair();
     const sendRatchetResult = await calculateRatchet(rootKey, sendRatchet, remoteRatchetKey);

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

@@ -4,7 +4,7 @@ import { normalizeDeviceJid, parseSignalAddressFromJid, signalAddressKey } from
 import { bytesToHex, uint8Equal } from '../../util/bytes.js';
 import { toError } from '../../util/primitives.js';
 export function createSignalSessionResolver(options) {
-    const { signalProtocol, signalStore, signalIdentitySync, signalSessionSync, logger } = options;
+    const { signalProtocol, sessionStore, identityStore, signalIdentitySync, signalSessionSync, logger } = options;
     const dedup = new PromiseDedup();
     const ensureSessionInternal = async (address, jid, expectedIdentity, reasonIdentity = false, prefetchedBundle) => {
         const expectedSerializedIdentity = expectedIdentity
@@ -13,9 +13,9 @@ export function createSignalSessionResolver(options) {
         if (reasonIdentity) {
             await signalIdentitySync.syncIdentityKeys([jid]);
         }
-        if (await signalStore.hasSession(address)) {
+        if (await sessionStore.hasSession(address)) {
             if (expectedSerializedIdentity) {
-                const storedIdentity = await signalStore.getRemoteIdentity(address);
+                const storedIdentity = await identityStore.getRemoteIdentity(address);
                 if (!storedIdentity || !uint8Equal(storedIdentity, expectedSerializedIdentity)) {
                     throw new Error('identity mismatch');
                 }
@@ -38,7 +38,7 @@ export function createSignalSessionResolver(options) {
         }
         const remoteIdentity = toSerializedPubKey(fetched.bundle.identity);
         if (reasonIdentity) {
-            const storedIdentity = await signalStore.getRemoteIdentity(address);
+            const storedIdentity = await identityStore.getRemoteIdentity(address);
             if (storedIdentity && !uint8Equal(remoteIdentity, storedIdentity)) {
                 throw new Error('identity mismatch');
             }
@@ -96,7 +96,7 @@ export function createSignalSessionResolver(options) {
                 }
             }
         }
-        const resolvedByIndex = (await signalStore.getSessionsBatch(normalizedTargetAddresses));
+        const resolvedByIndex = (await sessionStore.getSessionsBatch(normalizedTargetAddresses));
         const collectResolvedTargets = () => {
             const resolvedTargets = new Array(normalizedTargetJids.length);
             let resolvedTargetCount = 0;
@@ -199,7 +199,7 @@ export function createSignalSessionResolver(options) {
             for (let i = 0; i < fallbackIndices.length; i++) {
                 fallbackAddresses[i] = normalizedTargetAddresses[fallbackIndices[i]];
             }
-            const fallbackSessions = await signalStore.getSessionsBatch(fallbackAddresses);
+            const fallbackSessions = await sessionStore.getSessionsBatch(fallbackAddresses);
             for (let i = 0; i < fallbackIndices.length; i++) {
                 const session = fallbackSessions[i];
                 if (session) {

package/dist/esm/store/contracts/identity.store.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/store/contracts/message-secret.store.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/store/contracts/pre-key.store.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/store/contracts/session.store.js

@@ -0,0 +1 @@
+export {};