zapo-js 0.2.0 → 0.3.0

package/dist/signal/crypto/WaAdvSignature.js

@@ -1,16 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE = exports.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = exports.ADV_PREFIX_DEVICE_SIGNATURE = exports.ADV_PREFIX_ACCOUNT_SIGNATURE = void 0;
-exports.verifySignalSignature = verifySignalSignature;
-exports.signSignalMessage = signSignalMessage;
 exports.verifyDeviceIdentityAccountSignature = verifyDeviceIdentityAccountSignature;
 exports.generateDeviceSignature = generateDeviceSignature;
 exports.computeAdvIdentityHmac = computeAdvIdentityHmac;
 const _crypto_1 = require("../../crypto/index.js");
-const X25519_1 = require("../../crypto/curves/X25519");
-const edwards_1 = require("../../crypto/math/edwards");
-const le_1 = require("../../crypto/math/le");
-const mod_1 = require("../../crypto/math/mod");
 const constants_1 = require("../crypto/constants");
 const bytes_1 = require("../../util/bytes");
 var constants_2 = require("../crypto/constants");
@@ -18,57 +12,15 @@ Object.defineProperty(exports, "ADV_PREFIX_ACCOUNT_SIGNATURE", { enumerable: tru
 Object.defineProperty(exports, "ADV_PREFIX_DEVICE_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_DEVICE_SIGNATURE; } });
 Object.defineProperty(exports, "ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE; } });
 Object.defineProperty(exports, "ADV_PREFIX_HOSTED_DEVICE_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE; } });
-async function verifySignalSignature(publicKey, message, signature) {
-    if (signature.length !== 64) {
-        return false;
-    }
-    if ((signature[63] & 0x60) !== 0) {
-        return false;
-    }
-    const signatureLastByteIndex = 63;
-    const originalSignatureLastByte = signature[signatureLastByteIndex];
-    const signBit = originalSignatureLastByte & 0x80;
-    signature[signatureLastByteIndex] = originalSignatureLastByte & 0x7f;
-    const curvePublic = (0, _crypto_1.toRawPubKey)(publicKey);
-    const edPublic = (0, X25519_1.montgomeryToEdwardsPublic)(curvePublic, signBit);
-    try {
-        return await _crypto_1.Ed25519.verify(message, signature, edPublic);
-    }
-    finally {
-        signature[signatureLastByteIndex] = originalSignatureLastByte;
-    }
-}
-async function signSignalMessage(privateKey, message) {
-    (0, bytes_1.assertByteLength)(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
-    const clampedPrivateKey = (0, X25519_1.clampCurvePrivateKeyInPlace)(privateKey);
-    const privateScalar = (0, le_1.bytesToBigIntLE)(clampedPrivateKey);
-    const encodedPublic = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(privateScalar));
-    const pubKeySignBit = encodedPublic[31] & 0x80;
-    const randomSuffix = await (0, _crypto_1.randomBytesAsync)(64);
-    const hashInput = (0, bytes_1.concatBytes)([
-        constants_1.SIGNAL_PREFIX_SIGNATURE_RANDOM,
-        clampedPrivateKey,
-        message,
-        randomSuffix
-    ]);
-    const r = (0, mod_1.modGroup)((0, le_1.bytesToBigIntLE)(await (0, _crypto_1.sha512)(hashInput)));
-    const encodedR = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(r));
-    const hInput = (0, bytes_1.concatBytes)([encodedR, encodedPublic, message]);
-    const h = (0, mod_1.modGroup)((0, le_1.bytesToBigIntLE)(await (0, _crypto_1.sha512)(hInput)));
-    const s = (0, mod_1.modGroup)(r + h * privateScalar);
-    const encodedS = (0, le_1.bigIntToBytesLE)(s, 32);
-    encodedS[31] = (encodedS[31] & 0x7f) | pubKeySignBit;
-    return (0, bytes_1.concatBytes)([encodedR, encodedS]);
-}
 async function verifyDeviceIdentityAccountSignature(details, accountSignature, identityPublicKey, accountSignatureKey, isHosted = false) {
     const prefix = isHosted ? constants_1.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE : constants_1.ADV_PREFIX_ACCOUNT_SIGNATURE;
     const message = (0, bytes_1.concatBytes)([prefix, details, identityPublicKey]);
-    return verifySignalSignature(accountSignatureKey, message, accountSignature);
+    return (0, _crypto_1.xeddsaVerify)((0, _crypto_1.toRawPubKey)(accountSignatureKey), message, accountSignature);
 }
 async function generateDeviceSignature(details, identityKeyPair, accountSignatureKey, isHosted = false) {
     const prefix = isHosted ? constants_1.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE : constants_1.ADV_PREFIX_DEVICE_SIGNATURE;
     const message = (0, bytes_1.concatBytes)([prefix, details, identityKeyPair.pubKey, accountSignatureKey]);
-    return signSignalMessage(identityKeyPair.privKey, message);
+    return (0, _crypto_1.xeddsaSign)(identityKeyPair.privKey, message);
 }
 async function computeAdvIdentityHmac(secretKey, details) {
     const key = await (0, _crypto_1.importHmacKey)(secretKey);

package/dist/signal/crypto/constants.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE = exports.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = exports.ADV_PREFIX_DEVICE_SIGNATURE = exports.ADV_PREFIX_ACCOUNT_SIGNATURE = exports.SIGNAL_PREFIX_SIGNATURE_RANDOM = void 0;
-exports.SIGNAL_PREFIX_SIGNATURE_RANDOM = new Uint8Array([
-    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
-]);
+exports.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE = exports.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = exports.ADV_PREFIX_DEVICE_SIGNATURE = exports.ADV_PREFIX_ACCOUNT_SIGNATURE = void 0;
 exports.ADV_PREFIX_ACCOUNT_SIGNATURE = new Uint8Array([6, 0]);
 exports.ADV_PREFIX_DEVICE_SIGNATURE = new Uint8Array([6, 1]);
 exports.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = new Uint8Array([6, 5]);

package/dist/signal/encoding.js

@@ -5,6 +5,11 @@ exports.decodeSignalAddressFromRow = decodeSignalAddressFromRow;
 exports.decodeSignalRegistrationRow = decodeSignalRegistrationRow;
 exports.decodeSignalPreKeyRow = decodeSignalPreKeyRow;
 exports.decodeSignalSignedPreKeyRow = decodeSignalSignedPreKeyRow;
+exports.encodeSignalSessionSnapshot = encodeSignalSessionSnapshot;
+exports.encodeSignalRecvChain = encodeSignalRecvChain;
+exports.decodeSignalMessageKey = decodeSignalMessageKey;
+exports.decodeSignalRecvChain = decodeSignalRecvChain;
+exports.decodeSignalSessionSnapshot = decodeSignalSessionSnapshot;
 exports.encodeSignalSessionRecord = encodeSignalSessionRecord;
 exports.decodeSignalSessionRecord = decodeSignalSessionRecord;
 exports.encodeSenderKeyRecord = encodeSenderKeyRecord;
@@ -70,13 +75,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,
@@ -105,20 +104,7 @@ function encodeSignalRecvChain(chain) {
             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) {
@@ -148,13 +134,7 @@ function decodeSignalRecvChain(chain, field) {
         ratchetPubKey,
         nextMsgIndex: (0, coercion_1.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) {
@@ -213,13 +193,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: (0, coercion_1.asOptionalNumber)(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
@@ -235,13 +209,7 @@ function decodeSignalSessionSnapshot(session, field) {
 function encodeSignalSessionRecord(record) {
     return _proto_1.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();
 }
 function decodeSignalSessionRecord(raw) {
@@ -252,13 +220,7 @@ 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 ?? []
     };
 }
 function encodeSenderKeyRecord(record) {

package/dist/signal/group/SenderKeyChain.js

@@ -5,9 +5,9 @@ exports.deriveSenderKeyMsgKey = deriveSenderKeyMsgKey;
 const _crypto_1 = require("../../crypto/index.js");
 const constants_1 = require("../constants");
 const bytes_1 = require("../../util/bytes");
-async function selectMessageKey(senderKey, targetIteration) {
+async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
     const delta = targetIteration - senderKey.iteration;
-    if (delta > constants_1.SENDER_KEY_FUTURE_MESSAGES_MAX) {
+    if (delta > (futureMessagesMax ?? constants_1.SENDER_KEY_FUTURE_MESSAGES_MAX)) {
         throw new Error('sender key message is too far in future');
     }
     const currentUnused = senderKey.unusedMessageKeys ?? [];

package/dist/signal/group/SenderKeyCodec.js

@@ -20,13 +20,12 @@ function parseDistributionPayload(payload) {
         decoded.signingKey === undefined) {
         throw new Error('invalid sender key distribution message');
     }
-    const chainKey = (0, bytes_1.toBytesView)(decoded.chainKey);
-    (0, bytes_1.assertByteLength)(chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
+    (0, bytes_1.assertByteLength)(decoded.chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,
-        chainKey,
-        signingPublicKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(decoded.signingKey))
+        chainKey: decoded.chainKey,
+        signingPublicKey: (0, _crypto_1.toSerializedPubKey)(decoded.signingKey)
     };
 }
 function parseSenderKeyMessage(versionContentMac) {
@@ -43,7 +42,7 @@ function parseSenderKeyMessage(versionContentMac) {
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,
-        ciphertext: (0, bytes_1.toBytesView)(decoded.ciphertext),
+        ciphertext: decoded.ciphertext,
         versionContentMac
     };
 }

package/dist/signal/group/SenderKeyManager.js

@@ -7,7 +7,6 @@ const _proto_1 = require("../../proto.js");
 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");
 const bytes_1 = require("../../util/bytes");
@@ -29,9 +28,11 @@ async function aesCbcDecryptFromSeed(seed, ciphertext) {
     return (0, _crypto_1.aesCbcDecrypt)(await (0, _crypto_1.importAesCbcKey)(keyBytes), iv, ciphertext);
 }
 class SenderKeyManager {
-    constructor(store) {
+    constructor(store, options) {
         this.senderLock = new StoreLock_1.StoreLock();
         this.store = store;
+        this.getFutureMessagesMax = options?.getFutureMessagesMax;
+        this.skipSignatureVerification = options?.skipSignatureVerification === true;
     }
     async prepareGroupEncryption(groupId, sender, plaintext) {
         return this.runWithSenderLock(groupId, sender, async () => {
@@ -62,7 +63,7 @@ class SenderKeyManager {
                 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);
+            const signature = await (0, _crypto_1.xeddsaSign)(senderKey.signingPrivateKey, versionedContent);
             if (signature.length !== constants_1.SIGNAL_SIGNATURE_LENGTH) {
                 throw new Error(`invalid sender key signature length ${signature.length}`);
             }
@@ -166,13 +167,15 @@ class SenderKeyManager {
                 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');
+            if (!this.skipSignatureVerification) {
+                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, _crypto_1.xeddsaVerify)((0, _crypto_1.toRawPubKey)(senderKey.signingPublicKey), signedContent, signature);
+                if (!validSignature) {
+                    throw new Error('invalid sender key signature');
+                }
             }
-            const selected = await (0, SenderKeyChain_1.selectMessageKey)(senderKey, parsed.iteration);
+            const selected = await (0, SenderKeyChain_1.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/signal/registration/keygen.js

@@ -7,7 +7,6 @@ exports.generateRegistrationId = generateRegistrationId;
 const _crypto_1 = require("../../crypto/index.js");
 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(),
@@ -28,7 +27,7 @@ async function generatePreKeyPair(keyId) {
 async function generateSignedPreKey(keyId, signingPrivateKey) {
     const keyPair = await X25519_1.X25519.generateKeyPair();
     const serializedPubKey = (0, keys_1.toSerializedPubKey)(keyPair.pubKey);
-    const signature = await (0, WaAdvSignature_1.signSignalMessage)(signingPrivateKey, serializedPubKey);
+    const signature = await (0, _crypto_1.xeddsaSign)(signingPrivateKey, serializedPubKey);
     return {
         keyId,
         keyPair,

package/dist/signal/registration/utils.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAndStoreInitialKeys = createAndStoreInitialKeys;
 const keygen_1 = require("../registration/keygen");
-async function createAndStoreInitialKeys(store) {
+async function createAndStoreInitialKeys(store, preKeyStore) {
     const [registrationInfo, firstPreKey] = await Promise.all([
         (0, keygen_1.generateRegistrationInfo)(),
         (0, keygen_1.generatePreKeyPair)(1)
@@ -11,7 +11,7 @@ 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/signal/session/SignalProtocol.js

@@ -5,6 +5,7 @@ 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 encoding_1 = require("../encoding");
 const SignalRatchet_1 = require("../session/SignalRatchet");
 const SignalSerializer_1 = require("../session/SignalSerializer");
 const SignalSession_1 = require("../session/SignalSession");
@@ -16,15 +17,15 @@ function signalAddressLockKey(address) {
     return `signal:${signalAddressMapKey(address)}`;
 }
 class SignalProtocol {
-    constructor(store, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
-        this.store = store;
+    constructor(stores, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
+        this.stores = stores;
         this.logger = logger;
         this.sessionMutationLock = new StoreLock_1.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 = (0, _crypto_1.toSerializedPubKey)(remoteBundle.identity);
                     if (!(0, bytes_1.uint8Equal)(existing.remote.pubKey, remoteIdentity)) {
@@ -34,13 +35,13 @@ class SignalProtocol {
                 }
             }
             const [local, localOneTimeBase] = await Promise.all([
-                (0, SignalSession_1.requireLocalIdentity)(this.store),
+                (0, SignalSession_1.requireLocalIdentity)(this.stores.signal),
                 (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);
+            await this.stores.identity.setRemoteIdentity(address, session.remote.pubKey);
+            await this.stores.session.setSession(address, session);
             return session;
         });
     }
@@ -88,7 +89,7 @@ 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];
@@ -142,7 +143,7 @@ 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;
@@ -150,13 +151,13 @@ 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 = (0, SignalSerializer_1.deserializePkMsg)(envelope.ciphertext);
@@ -175,9 +176,9 @@ class SignalProtocol {
             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.stores.identity.setRemoteIdentity(address, nextRemoteIdentity);
             }
-            await this.store.setSession(address, outcome.updatedSession);
+            await this.stores.session.setSession(address, outcome.updatedSession);
             return outcome.plaintext;
         });
     }
@@ -195,11 +196,11 @@ class SignalProtocol {
             };
         }
         const [local, signedPreKey, oneTimePreKey] = await Promise.all([
-            (0, SignalSession_1.requireLocalIdentity)(this.store),
-            (0, SignalSerializer_1.requireSignedPreKey)(this.store, parsed.localSignedPreKeyId),
+            (0, SignalSession_1.requireLocalIdentity)(this.stores.signal),
+            (0, SignalSerializer_1.requireSignedPreKey)(this.stores.signal, parsed.localSignedPreKeyId),
             parsed.localOneTimeKeyId === null || parsed.localOneTimeKeyId === undefined
                 ? Promise.resolve(null)
-                : (0, SignalSerializer_1.requirePreKey)(this.store, parsed.localOneTimeKeyId)
+                : (0, SignalSerializer_1.requirePreKey)(this.stores.preKey, parsed.localOneTimeKeyId)
         ]);
         const incoming = await (0, SignalSession_1.initiateSessionIncoming)(local, parsed.remote, parsed.sessionBaseKey, {
             signed: (0, SignalSession_1.toSerializedKeyPair)(signedPreKey.keyPair),
@@ -213,7 +214,7 @@ class SignalProtocol {
             ? {
                 ...incoming,
                 prevSessions: [
-                    (0, SignalSession_1.detachSession)(currentSession),
+                    (0, encoding_1.encodeSignalSessionSnapshot)((0, SignalSession_1.detachSession)(currentSession)),
                     ...currentSession.prevSessions.slice(0, constants_1.MAX_PREV_SESSIONS - 1)
                 ]
             }
@@ -221,7 +222,7 @@ class SignalProtocol {
         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);
+            await this.stores.preKey.consumePreKeyById(parsed.localOneTimeKeyId);
         }
         return {
             updatedSession,

package/dist/signal/session/SignalRatchet.js

@@ -9,6 +9,7 @@ exports.decryptMsgFromSession = decryptMsgFromSession;
 const _crypto_1 = require("../../crypto/index.js");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../constants");
+const encoding_1 = require("../encoding");
 const SignalSession_1 = require("../session/SignalSession");
 const bytes_1 = require("../../util/bytes");
 const primitives_1 = require("../../util/primitives");
@@ -43,7 +44,7 @@ async function selectMessageKey(chain, targetCounter) {
         if (idx === -1) {
             throw new Error('duplicate message');
         }
-        const messageKey = unused[idx];
+        const messageKey = (0, encoding_1.decodeSignalMessageKey)(unused[idx], `unusedMsgKeys[${idx}]`);
         const nextUnused = (0, bytes_1.removeAt)(unused, idx);
         return {
             messageKey,
@@ -81,7 +82,12 @@ 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;
@@ -182,13 +188,14 @@ async function decryptMsg(session, parsed, onPrevSessionDecryptError) {
     }
     catch (error) {
         for (let i = 0; i < session.prevSessions.length; i += 1) {
-            const prevSession = (0, SignalSession_1.snapshotToRecord)(session.prevSessions[i]);
+            const decodedPrev = (0, encoding_1.decodeSignalSessionSnapshot)(session.prevSessions[i], `prevSessions[${i}]`);
+            const prevSession = (0, SignalSession_1.snapshotToRecord)(decodedPrev);
             try {
                 const [updatedPrev, plaintext] = await decryptMsgFromSession(prevSession, parsed);
                 const updatedSession = {
                     ...updatedPrev,
                     prevSessions: [
-                        (0, SignalSession_1.detachSession)(session),
+                        (0, encoding_1.encodeSignalSessionSnapshot)((0, SignalSession_1.detachSession)(session)),
                         ...session.prevSessions.slice(0, i),
                         ...session.prevSessions.slice(i + 1)
                     ]
@@ -215,7 +222,10 @@ async function decryptMsg(session, parsed, onPrevSessionDecryptError) {
 }
 async function decryptMsgFromSession(session, message) {
     const ratchetPubKey = (0, _crypto_1.toSerializedPubKey)(message.ratchetPubKey);
-    const recvChainIndex = session.recvChains.findIndex((entry) => (0, bytes_1.uint8Equal)(entry.ratchetPubKey, ratchetPubKey));
+    const recvChainIndex = session.recvChains.findIndex((raw) => {
+        const key = raw.senderRatchetKey;
+        return key !== null && key !== undefined && (0, bytes_1.uint8Equal)(key, ratchetPubKey);
+    });
     let selectedMessageKey;
     let updatedSession;
     if (recvChainIndex === -1) {
@@ -233,7 +243,7 @@ async function decryptMsgFromSession(session, message) {
         selectedMessageKey = selected.messageKey;
         const sendRatchet = await (0, SignalSession_1.calculateRatchet)(recvRatchet.rootKey, newSendRatchet, ratchetPubKey);
         const nextRecvChains = session.recvChains.slice(-MAX_TRACKED_RECV_CHAINS);
-        nextRecvChains.push(selected.updatedChain);
+        nextRecvChains.push((0, encoding_1.encodeSignalRecvChain)(selected.updatedChain));
         updatedSession = {
             ...session,
             rootKey: sendRatchet.rootKey,
@@ -248,10 +258,11 @@ async function decryptMsgFromSession(session, message) {
         };
     }
     else {
-        const selected = await selectMessageKey(session.recvChains[recvChainIndex], message.counter);
+        const decoded = (0, encoding_1.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] = (0, encoding_1.encodeSignalRecvChain)(selected.updatedChain);
         updatedSession = {
             ...session,
             recvChains: nextRecvChains

package/dist/signal/session/SignalSerializer.js

@@ -7,7 +7,6 @@ exports.requirePreKey = requirePreKey;
 const _crypto_1 = require("../../crypto/index.js");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../constants");
-const bytes_1 = require("../../util/bytes");
 function deserializeMsg(versionContentMac) {
     const content = (0, _crypto_1.readVersionedContent)(versionContentMac, constants_1.SIGNAL_VERSION, constants_1.SIGNAL_MAC_SIZE);
     const parsed = _proto_1.proto.SignalMessage.decode(content);
@@ -20,9 +19,9 @@ function deserializeMsg(versionContentMac) {
         throw new Error('invalid signal message');
     }
     return {
-        ratchetPubKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.ratchetKey)),
+        ratchetPubKey: (0, _crypto_1.toSerializedPubKey)(parsed.ratchetKey),
         counter: parsed.counter,
-        ciphertext: (0, bytes_1.toBytesView)(parsed.ciphertext),
+        ciphertext: parsed.ciphertext,
         versionContentMac
     };
 }
@@ -41,14 +40,14 @@ function deserializePkMsg(versionContent) {
         parsed.message === undefined) {
         throw new Error('invalid prekey signal message');
     }
-    const signal = deserializeMsg((0, bytes_1.toBytesView)(parsed.message));
+    const signal = deserializeMsg(parsed.message);
     return {
         ...signal,
         remote: {
             regId: parsed.registrationId,
-            pubKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.identityKey))
+            pubKey: (0, _crypto_1.toSerializedPubKey)(parsed.identityKey)
         },
-        sessionBaseKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.baseKey)),
+        sessionBaseKey: (0, _crypto_1.toSerializedPubKey)(parsed.baseKey),
         localSignedPreKeyId: parsed.signedPreKeyId,
         localOneTimeKeyId: parsed.preKeyId ?? null
     };

package/dist/signal/session/SignalSession.js

@@ -12,6 +12,7 @@ exports.toSerializedKeyPair = toSerializedKeyPair;
 exports.ecdh = ecdh;
 const _crypto_1 = require("../../crypto/index.js");
 const constants_1 = require("../constants");
+const encoding_1 = require("../encoding");
 const bytes_1 = require("../../util/bytes");
 function snapshotToRecord(snapshot) {
     return {
@@ -33,19 +34,21 @@ function findMatchingSession(session, sessionBaseKey) {
         return session;
     }
     for (let index = 0; index < session.prevSessions.length; index += 1) {
-        const previousSession = session.prevSessions[index];
-        if (!previousSession.aliceBaseKey ||
-            !(0, bytes_1.uint8Equal)(previousSession.aliceBaseKey, serializedBaseKey)) {
+        const rawPrev = session.prevSessions[index];
+        if (!rawPrev.aliceBaseKey || !(0, bytes_1.uint8Equal)(rawPrev.aliceBaseKey, serializedBaseKey)) {
             continue;
         }
-        const prevSessions = [detachSession(session)];
+        const decoded = (0, encoding_1.decodeSignalSessionSnapshot)(rawPrev, `prevSessions[${index}]`);
+        const prevSessions = [
+            (0, encoding_1.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
         };
     }
@@ -85,10 +88,9 @@ async function initiateSessionOutgoing(local, remoteBundle, localOneTimeBase) {
     ]);
     const [rootKey, chainKey] = await (0, _crypto_1.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);