zapo-js 0.1.2 → 0.2.0

package/dist/signal/{store/sqlite.js → encoding.js}

@@ -10,12 +10,12 @@ exports.decodeSignalSessionRecord = decodeSignalSessionRecord;
 exports.encodeSenderKeyRecord = encodeSenderKeyRecord;
 exports.decodeSenderKeyRecord = decodeSenderKeyRecord;
 exports.decodeSenderKeyDistributionRow = decodeSenderKeyDistributionRow;
-exports.decodeSqliteCount = decodeSqliteCount;
+exports.decodeStoreCount = decodeStoreCount;
 exports.decodeSignalRemoteIdentity = decodeSignalRemoteIdentity;
-const _proto_1 = require("../../proto.js");
-const constants_1 = require("../../protocol/constants");
-const bytes_1 = require("../../util/bytes");
-const coercion_1 = require("../../util/coercion");
+const _proto_1 = require("../proto.js");
+const constants_1 = require("../protocol/constants");
+const bytes_1 = require("../util/bytes");
+const coercion_1 = require("../util/coercion");
 function toSignalAddressParts(address) {
     return {
         user: address.user,
@@ -70,7 +70,13 @@ function encodeSignalSessionSnapshot(session) {
         rootKey: session.rootKey,
         previousCounter: session.prevSendChainHighestIndex,
         senderChain: encodeSignalSendChain(session.sendChain),
-        receiverChains: session.recvChains.map((chain) => encodeSignalRecvChain(chain)),
+        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;
+        })(),
         pendingPreKey: session.initialExchangeInfo
             ? {
                 preKeyId: session.initialExchangeInfo.remoteOneTimeId ?? undefined,
@@ -99,12 +105,20 @@ function encodeSignalRecvChain(chain) {
             index: chain.nextMsgIndex,
             key: chain.chainKey
         },
-        messageKeys: (chain.unusedMsgKeys ?? []).map((messageKey) => ({
-            index: messageKey.index,
-            cipherKey: messageKey.cipherKey,
-            macKey: messageKey.macKey,
-            iv: messageKey.iv
-        }))
+        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;
+        })()
     };
 }
 function decodeSignalMessageKey(messageKey, field) {
@@ -134,7 +148,13 @@ function decodeSignalRecvChain(chain, field) {
         ratchetPubKey,
         nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
         chainKey: chainKeyBytes,
-        unusedMsgKeys: (chain.messageKeys ?? []).map((messageKey, index) => decodeSignalMessageKey(messageKey, `${field}.messageKeys[${index}]`))
+        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;
+        })()
     };
 }
 function decodeSignalSendChain(chain, field) {
@@ -193,7 +213,13 @@ function decodeSignalSessionSnapshot(session, field) {
         },
         rootKey,
         sendChain: decodeSignalSendChain(senderChain, `${field}.senderChain`),
-        recvChains: (session.receiverChains ?? []).map((chain, index) => decodeSignalRecvChain(chain, `${field}.receiverChains[${index}]`)),
+        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;
+        })(),
         initialExchangeInfo: pendingPreKey
             ? {
                 remoteOneTimeId: (0, coercion_1.asOptionalNumber)(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
@@ -209,7 +235,13 @@ function decodeSignalSessionSnapshot(session, field) {
 function encodeSignalSessionRecord(record) {
     return _proto_1.proto.RecordStructure.encode({
         currentSession: encodeSignalSessionSnapshot(record),
-        previousSessions: record.prevSessions.map((session) => encodeSignalSessionSnapshot(session))
+        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;
+        })()
     }).finish();
 }
 function decodeSignalSessionRecord(raw) {
@@ -220,7 +252,13 @@ function decodeSignalSessionRecord(raw) {
     const current = decodeSignalSessionSnapshot(decoded.currentSession, 'signal_sessions.currentSession');
     return {
         ...current,
-        prevSessions: (decoded.previousSessions ?? []).map((session, index) => decodeSignalSessionSnapshot(session, `signal_sessions.previousSessions[${index}]`))
+        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;
+        })()
     };
 }
 function encodeSenderKeyRecord(record) {
@@ -236,10 +274,18 @@ function encodeSenderKeyRecord(record) {
                     public: record.signingPublicKey,
                     private: record.signingPrivateKey
                 },
-                senderMessageKeys: (record.unusedMessageKeys ?? []).map((messageKey) => ({
-                    iteration: messageKey.iteration,
-                    seed: messageKey.seed
-                }))
+                senderMessageKeys: (() => {
+                    const src = record.unusedMessageKeys ?? [];
+                    const arr = new Array(src.length);
+                    for (let i = 0; i < src.length; i += 1) {
+                        const messageKey = src[i];
+                        arr[i] = {
+                            iteration: messageKey.iteration,
+                            seed: messageKey.seed
+                        };
+                    }
+                    return arr;
+                })()
             }
         ]
     }).finish();
@@ -259,10 +305,18 @@ function decodeSenderKeyState(state, field) {
         signingPrivateKey: state.senderSigningKey.private !== null && state.senderSigningKey.private !== undefined
             ? (0, coercion_1.asBytes)(state.senderSigningKey.private, `${field}.senderSigningKey.private`)
             : undefined,
-        unusedMessageKeys: (state.senderMessageKeys ?? []).map((messageKey, index) => ({
-            iteration: (0, coercion_1.asNumber)(messageKey.iteration, `${field}.senderMessageKeys[${index}].iteration`),
-            seed: (0, coercion_1.asBytes)(messageKey.seed, `${field}.senderMessageKeys[${index}].seed`)
-        }))
+        unusedMessageKeys: (() => {
+            const src = state.senderMessageKeys ?? [];
+            const arr = new Array(src.length);
+            for (let i = 0; i < src.length; i += 1) {
+                const messageKey = src[i];
+                arr[i] = {
+                    iteration: (0, coercion_1.asNumber)(messageKey.iteration, `${field}.senderMessageKeys[${i}].iteration`),
+                    seed: (0, coercion_1.asBytes)(messageKey.seed, `${field}.senderMessageKeys[${i}].seed`)
+                };
+            }
+            return arr;
+        })()
     };
 }
 function decodeSenderKeyRecord(raw, groupId, sender) {
@@ -295,7 +349,7 @@ function decodeSenderKeyDistributionRow(row) {
         timestampMs: (0, coercion_1.asNumber)(row.timestamp_ms, 'sender_key_distribution.timestamp_ms')
     };
 }
-function decodeSqliteCount(row, field) {
+function decodeStoreCount(row, field) {
     return row ? (0, coercion_1.asNumber)(row.count, field) : 0;
 }
 function decodeSignalRemoteIdentity(raw) {

package/dist/signal/group/SenderKeyCodec.js

@@ -4,10 +4,11 @@ exports.parseDistributionPayload = parseDistributionPayload;
 exports.parseSenderKeyMessage = parseSenderKeyMessage;
 const _crypto_1 = require("../../crypto/index.js");
 const _proto_1 = require("../../proto.js");
-const constants_1 = require("../constants");
+const constants_1 = require("../api/constants");
+const constants_2 = require("../constants");
 const bytes_1 = require("../../util/bytes");
 function parseDistributionPayload(payload) {
-    const body = (0, _crypto_1.readVersionedContent)(payload, constants_1.SIGNAL_GROUP_VERSION, 0);
+    const body = (0, _crypto_1.readVersionedContent)(payload, constants_2.SIGNAL_GROUP_VERSION, 0);
     const decoded = _proto_1.proto.SenderKeyDistributionMessage.decode(body);
     if (decoded.id === null ||
         decoded.id === undefined ||
@@ -29,7 +30,7 @@ function parseDistributionPayload(payload) {
     };
 }
 function parseSenderKeyMessage(versionContentMac) {
-    const body = (0, _crypto_1.readVersionedContent)(versionContentMac, constants_1.SIGNAL_GROUP_VERSION, constants_1.SIGNATURE_SIZE);
+    const body = (0, _crypto_1.readVersionedContent)(versionContentMac, constants_2.SIGNAL_GROUP_VERSION, constants_1.SIGNAL_SIGNATURE_LENGTH);
     const decoded = _proto_1.proto.SenderKeyMessage.decode(body);
     if (decoded.id === null ||
         decoded.id === undefined ||

package/dist/signal/group/SenderKeyManager.js

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

package/dist/signal/index.js

@@ -1,6 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSignalSessionResolver = exports.SignalProtocol = exports.createAndStoreInitialKeys = exports.SenderKeyManager = exports.SignalSessionSyncApi = exports.SignalRotateKeyApi = exports.SignalMissingPreKeysSyncApi = exports.SignalIdentitySyncApi = exports.SignalDeviceSyncApi = exports.SignalDigestSyncApi = exports.parsePreKeyUploadFailure = exports.buildPreKeyUploadIq = exports.generateSignedPreKey = exports.generateRegistrationInfo = exports.generateRegistrationId = exports.generatePreKeyPair = void 0;
+exports.createSignalSessionResolver = exports.SignalProtocol = exports.createAndStoreInitialKeys = exports.SenderKeyManager = exports.SignalSessionSyncApi = exports.SignalRotateKeyApi = exports.SignalMissingPreKeysSyncApi = exports.SignalIdentitySyncApi = exports.SignalDeviceSyncApi = exports.SignalDigestSyncApi = exports.parsePreKeyUploadFailure = exports.buildPreKeyUploadIq = exports.generateSignedPreKey = exports.generateRegistrationInfo = exports.generateRegistrationId = exports.generatePreKeyPair = exports.toSignalAddressParts = exports.encodeSignalSessionRecord = exports.encodeSenderKeyRecord = exports.decodeStoreCount = exports.decodeSenderKeyRecord = exports.decodeSenderKeyDistributionRow = exports.decodeSignalSignedPreKeyRow = exports.decodeSignalSessionRecord = exports.decodeSignalRemoteIdentity = exports.decodeSignalRegistrationRow = exports.decodeSignalPreKeyRow = void 0;
+var encoding_1 = require("./encoding");
+Object.defineProperty(exports, "decodeSignalPreKeyRow", { enumerable: true, get: function () { return encoding_1.decodeSignalPreKeyRow; } });
+Object.defineProperty(exports, "decodeSignalRegistrationRow", { enumerable: true, get: function () { return encoding_1.decodeSignalRegistrationRow; } });
+Object.defineProperty(exports, "decodeSignalRemoteIdentity", { enumerable: true, get: function () { return encoding_1.decodeSignalRemoteIdentity; } });
+Object.defineProperty(exports, "decodeSignalSessionRecord", { enumerable: true, get: function () { return encoding_1.decodeSignalSessionRecord; } });
+Object.defineProperty(exports, "decodeSignalSignedPreKeyRow", { enumerable: true, get: function () { return encoding_1.decodeSignalSignedPreKeyRow; } });
+Object.defineProperty(exports, "decodeSenderKeyDistributionRow", { enumerable: true, get: function () { return encoding_1.decodeSenderKeyDistributionRow; } });
+Object.defineProperty(exports, "decodeSenderKeyRecord", { enumerable: true, get: function () { return encoding_1.decodeSenderKeyRecord; } });
+Object.defineProperty(exports, "decodeStoreCount", { enumerable: true, get: function () { return encoding_1.decodeStoreCount; } });
+Object.defineProperty(exports, "encodeSenderKeyRecord", { enumerable: true, get: function () { return encoding_1.encodeSenderKeyRecord; } });
+Object.defineProperty(exports, "encodeSignalSessionRecord", { enumerable: true, get: function () { return encoding_1.encodeSignalSessionRecord; } });
+Object.defineProperty(exports, "toSignalAddressParts", { enumerable: true, get: function () { return encoding_1.toSignalAddressParts; } });
 var keygen_1 = require("./registration/keygen");
 Object.defineProperty(exports, "generatePreKeyPair", { enumerable: true, get: function () { return keygen_1.generatePreKeyPair; } });
 Object.defineProperty(exports, "generateRegistrationId", { enumerable: true, get: function () { return keygen_1.generateRegistrationId; } });

package/dist/signal/registration/keygen.js

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

package/dist/signal/registration/utils.js

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