zapo-js 0.1.0

package/dist/signal/session/SignalSerializer.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeMsg = deserializeMsg;
+exports.deserializePkMsg = deserializePkMsg;
+exports.requireSignedPreKey = requireSignedPreKey;
+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);
+    if (parsed.ratchetKey === null ||
+        parsed.ratchetKey === undefined ||
+        parsed.counter === null ||
+        parsed.counter === undefined ||
+        parsed.ciphertext === null ||
+        parsed.ciphertext === undefined) {
+        throw new Error('invalid signal message');
+    }
+    return {
+        ratchetPubKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.ratchetKey)),
+        counter: parsed.counter,
+        ciphertext: (0, bytes_1.toBytesView)(parsed.ciphertext),
+        versionContentMac
+    };
+}
+function deserializePkMsg(versionContent) {
+    const content = (0, _crypto_1.readVersionedContent)(versionContent, constants_1.SIGNAL_VERSION, 0);
+    const parsed = _proto_1.proto.PreKeySignalMessage.decode(content);
+    if (parsed.registrationId === null ||
+        parsed.registrationId === undefined ||
+        parsed.signedPreKeyId === null ||
+        parsed.signedPreKeyId === undefined ||
+        parsed.baseKey === null ||
+        parsed.baseKey === undefined ||
+        parsed.identityKey === null ||
+        parsed.identityKey === undefined ||
+        parsed.message === null ||
+        parsed.message === undefined) {
+        throw new Error('invalid prekey signal message');
+    }
+    const signal = deserializeMsg((0, bytes_1.toBytesView)(parsed.message));
+    return {
+        ...signal,
+        remote: {
+            regId: parsed.registrationId,
+            pubKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.identityKey))
+        },
+        sessionBaseKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.baseKey)),
+        localSignedPreKeyId: parsed.signedPreKeyId,
+        localOneTimeKeyId: parsed.preKeyId ?? null
+    };
+}
+async function requireSignedPreKey(store, id) {
+    const signedPreKey = await store.getSignedPreKeyById(id);
+    if (!signedPreKey) {
+        throw new Error(`signed prekey ${id} not found`);
+    }
+    return signedPreKey;
+}
+async function requirePreKey(store, id) {
+    const preKey = await store.getPreKeyById(id);
+    if (!preKey) {
+        throw new Error(`prekey ${id} not found`);
+    }
+    return preKey;
+}

package/dist/signal/session/SignalSession.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotToRecord = snapshotToRecord;
+exports.detachSession = detachSession;
+exports.findMatchingSession = findMatchingSession;
+exports.requireLocalIdentity = requireLocalIdentity;
+exports.initiateSessionOutgoing = initiateSessionOutgoing;
+exports.initiateSessionIncoming = initiateSessionIncoming;
+exports.calculateRatchet = calculateRatchet;
+exports.generateSerializedKeyPair = generateSerializedKeyPair;
+exports.toSerializedKeyPair = toSerializedKeyPair;
+exports.ecdh = ecdh;
+const _crypto_1 = require("../../crypto/index.js");
+const constants_1 = require("../constants");
+const bytes_1 = require("../../util/bytes");
+function snapshotToRecord(snapshot) {
+    return {
+        ...snapshot,
+        prevSessions: []
+    };
+}
+function detachSession(session) {
+    const { prevSessions, ...snapshot } = session;
+    void prevSessions;
+    return snapshot;
+}
+function findMatchingSession(session, sessionBaseKey) {
+    if (!session) {
+        return null;
+    }
+    const serializedBaseKey = (0, _crypto_1.toSerializedPubKey)(sessionBaseKey);
+    if (session.aliceBaseKey && (0, bytes_1.uint8Equal)(session.aliceBaseKey, serializedBaseKey)) {
+        return session;
+    }
+    const previousSessionIndex = session.prevSessions.findIndex((prev) => !!prev.aliceBaseKey && (0, bytes_1.uint8Equal)(prev.aliceBaseKey, serializedBaseKey));
+    if (previousSessionIndex !== -1) {
+        const promoted = snapshotToRecord(session.prevSessions[previousSessionIndex]);
+        return {
+            ...promoted,
+            prevSessions: [
+                detachSession(session),
+                ...session.prevSessions.slice(0, previousSessionIndex),
+                ...session.prevSessions.slice(previousSessionIndex + 1)
+            ]
+        };
+    }
+    return null;
+}
+async function requireLocalIdentity(store) {
+    const registration = await store.getRegistrationInfo();
+    if (!registration) {
+        throw new Error('registration info not found');
+    }
+    return {
+        regId: registration.registrationId,
+        staticKeyPair: toSerializedKeyPair(registration.identityKeyPair)
+    };
+}
+async function initiateSessionOutgoing(local, remoteBundle, localOneTimeBase) {
+    const remoteIdentity = (0, _crypto_1.toSerializedPubKey)(remoteBundle.identity);
+    const remoteSignedKey = (0, _crypto_1.toSerializedPubKey)(remoteBundle.signedKey.publicKey);
+    const remoteOneTimeKey = remoteBundle.oneTimeKey
+        ? (0, _crypto_1.toSerializedPubKey)(remoteBundle.oneTimeKey.publicKey)
+        : null;
+    const remoteRatchetKey = (0, _crypto_1.toSerializedPubKey)(remoteBundle.ratchetKey ?? remoteBundle.signedKey.publicKey);
+    const [signedDh, identityDh, baseDh, oneTimeDh] = await Promise.all([
+        ecdh(local.staticKeyPair.privKey, remoteSignedKey),
+        ecdh(localOneTimeBase.privKey, remoteIdentity),
+        ecdh(localOneTimeBase.privKey, remoteSignedKey),
+        remoteOneTimeKey
+            ? ecdh(localOneTimeBase.privKey, remoteOneTimeKey)
+            : Promise.resolve(null)
+    ]);
+    const secret = (0, bytes_1.concatBytes)([
+        constants_1.SIGNAL_PREFIX,
+        signedDh,
+        identityDh,
+        baseDh,
+        ...(oneTimeDh ? [oneTimeDh] : [])
+    ]);
+    const [rootKey, chainKey] = await (0, _crypto_1.hkdfSplit)(secret, null, 'WhisperText');
+    const recvChain = {
+        ratchetPubKey: remoteRatchetKey,
+        nextMsgIndex: 0,
+        chainKey,
+        unusedMsgKeys: []
+    };
+    const sendRatchet = await generateSerializedKeyPair();
+    const sendRatchetResult = await calculateRatchet(rootKey, sendRatchet, remoteRatchetKey);
+    return {
+        local: { regId: local.regId, pubKey: local.staticKeyPair.pubKey },
+        remote: { regId: remoteBundle.regId, pubKey: remoteIdentity },
+        rootKey: sendRatchetResult.rootKey,
+        recvChains: [recvChain],
+        sendChain: {
+            ratchetKey: sendRatchet,
+            nextMsgIndex: 0,
+            chainKey: sendRatchetResult.chainKey
+        },
+        initialExchangeInfo: {
+            remoteOneTimeId: remoteBundle.oneTimeKey?.id ?? null,
+            remoteSignedId: remoteBundle.signedKey.id,
+            localOneTimePubKey: localOneTimeBase.pubKey
+        },
+        prevSendChainHighestIndex: 0,
+        prevSessions: [],
+        aliceBaseKey: localOneTimeBase.pubKey
+    };
+}
+async function initiateSessionIncoming(local, remote, sessionBaseKey, localKeys) {
+    const baseKey = (0, _crypto_1.toSerializedPubKey)(sessionBaseKey);
+    const remotePub = (0, _crypto_1.toSerializedPubKey)(remote.pubKey);
+    const [identityDh, staticDh, signedDh, oneTimeDh] = await Promise.all([
+        ecdh(localKeys.signed.privKey, remotePub),
+        ecdh(local.staticKeyPair.privKey, baseKey),
+        ecdh(localKeys.signed.privKey, baseKey),
+        localKeys.oneTime
+            ? ecdh(localKeys.oneTime.privKey, baseKey)
+            : Promise.resolve(null)
+    ]);
+    const secret = (0, bytes_1.concatBytes)([
+        constants_1.SIGNAL_PREFIX,
+        identityDh,
+        staticDh,
+        signedDh,
+        ...(oneTimeDh ? [oneTimeDh] : [])
+    ]);
+    const [rootKey, chainKey] = await (0, _crypto_1.hkdfSplit)(secret, null, 'WhisperText');
+    return {
+        local: { regId: local.regId, pubKey: local.staticKeyPair.pubKey },
+        remote: { regId: remote.regId, pubKey: remotePub },
+        rootKey,
+        recvChains: [],
+        sendChain: {
+            ratchetKey: localKeys.ratchet,
+            nextMsgIndex: 0,
+            chainKey
+        },
+        initialExchangeInfo: null,
+        prevSendChainHighestIndex: 0,
+        prevSessions: [],
+        aliceBaseKey: baseKey
+    };
+}
+async function calculateRatchet(rootKey, localRatchet, remoteRatchetPubKey) {
+    const sharedSecret = await ecdh(localRatchet.privKey, remoteRatchetPubKey);
+    const [nextRootKey, chainKey] = await (0, _crypto_1.hkdfSplit)(sharedSecret, rootKey, 'WhisperRatchet');
+    return {
+        rootKey: nextRootKey,
+        chainKey
+    };
+}
+async function generateSerializedKeyPair() {
+    const pair = await _crypto_1.X25519.generateKeyPair();
+    return toSerializedKeyPair(pair);
+}
+function toSerializedKeyPair(pair) {
+    return {
+        pubKey: (0, _crypto_1.toSerializedPubKey)(pair.pubKey),
+        privKey: pair.privKey
+    };
+}
+async function ecdh(privateKey, publicKey) {
+    return _crypto_1.X25519.scalarMult(privateKey, (0, _crypto_1.toRawPubKey)(publicKey));
+}

package/dist/signal/store/sqlite.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSignalAddressParts = toSignalAddressParts;
+exports.decodeSignalAddressFromRow = decodeSignalAddressFromRow;
+exports.decodeSignalRegistrationRow = decodeSignalRegistrationRow;
+exports.decodeSignalPreKeyRow = decodeSignalPreKeyRow;
+exports.decodeSignalSignedPreKeyRow = decodeSignalSignedPreKeyRow;
+exports.encodeSignalSessionRecord = encodeSignalSessionRecord;
+exports.decodeSignalSessionRecord = decodeSignalSessionRecord;
+exports.encodeSenderKeyRecord = encodeSenderKeyRecord;
+exports.decodeSenderKeyRecord = decodeSenderKeyRecord;
+exports.decodeSenderKeyDistributionRow = decodeSenderKeyDistributionRow;
+exports.decodeSqliteCount = decodeSqliteCount;
+exports.decodeSignalRemoteIdentity = decodeSignalRemoteIdentity;
+const _proto_1 = require("../../proto.js");
+const constants_1 = require("../../protocol/constants");
+const coercion_1 = require("../../util/coercion");
+function toSignalAddressParts(address) {
+    return {
+        user: address.user,
+        server: address.server ?? constants_1.WA_DEFAULTS.HOST_DOMAIN,
+        device: address.device
+    };
+}
+function decodeSignalAddressFromRow(row) {
+    return {
+        user: (0, coercion_1.asString)(row.sender_user, 'signal.sender_user'),
+        server: (0, coercion_1.asString)(row.sender_server, 'signal.sender_server'),
+        device: (0, coercion_1.asNumber)(row.sender_device, 'signal.sender_device')
+    };
+}
+function decodeSignalRegistrationRow(row) {
+    return {
+        registrationId: (0, coercion_1.asNumber)(row.registration_id, 'signal_registration.registration_id'),
+        identityKeyPair: {
+            pubKey: (0, coercion_1.asBytes)(row.identity_pub_key, 'signal_registration.identity_pub_key'),
+            privKey: (0, coercion_1.asBytes)(row.identity_priv_key, 'signal_registration.identity_priv_key')
+        }
+    };
+}
+function decodeSignalPreKeyRow(row) {
+    return {
+        keyId: (0, coercion_1.asNumber)(row.key_id, 'signal_prekey.key_id'),
+        keyPair: {
+            pubKey: (0, coercion_1.asBytes)(row.pub_key, 'signal_prekey.pub_key'),
+            privKey: (0, coercion_1.asBytes)(row.priv_key, 'signal_prekey.priv_key')
+        },
+        uploaded: (0, coercion_1.toBoolOrUndef)(row.uploaded)
+    };
+}
+function decodeSignalSignedPreKeyRow(row) {
+    return {
+        keyId: (0, coercion_1.asNumber)(row.key_id, 'signal_signed_prekey.key_id'),
+        keyPair: {
+            pubKey: (0, coercion_1.asBytes)(row.pub_key, 'signal_signed_prekey.pub_key'),
+            privKey: (0, coercion_1.asBytes)(row.priv_key, 'signal_signed_prekey.priv_key')
+        },
+        signature: (0, coercion_1.asBytes)(row.signature, 'signal_signed_prekey.signature'),
+        uploaded: (0, coercion_1.toBoolOrUndef)(row.uploaded)
+    };
+}
+function encodeSignalSessionSnapshot(session) {
+    return {
+        sessionVersion: 3,
+        localRegistrationId: session.local.regId,
+        localIdentityPublic: session.local.pubKey,
+        remoteRegistrationId: session.remote.regId,
+        remoteIdentityPublic: session.remote.pubKey,
+        rootKey: session.rootKey,
+        previousCounter: session.prevSendChainHighestIndex,
+        senderChain: encodeSignalSendChain(session.sendChain),
+        receiverChains: session.recvChains.map((chain) => encodeSignalRecvChain(chain)),
+        pendingPreKey: session.initialExchangeInfo
+            ? {
+                preKeyId: session.initialExchangeInfo.remoteOneTimeId ?? undefined,
+                signedPreKeyId: session.initialExchangeInfo.remoteSignedId,
+                baseKey: session.initialExchangeInfo.localOneTimePubKey
+            }
+            : undefined,
+        aliceBaseKey: session.aliceBaseKey ?? undefined
+    };
+}
+function encodeSignalSendChain(chain) {
+    return {
+        senderRatchetKey: chain.ratchetKey.pubKey,
+        senderRatchetKeyPrivate: chain.ratchetKey.privKey,
+        chainKey: {
+            index: chain.nextMsgIndex,
+            key: chain.chainKey
+        },
+        messageKeys: []
+    };
+}
+function encodeSignalRecvChain(chain) {
+    return {
+        senderRatchetKey: chain.ratchetPubKey,
+        chainKey: {
+            index: chain.nextMsgIndex,
+            key: chain.chainKey
+        },
+        messageKeys: (chain.unusedMsgKeys ?? []).map((messageKey) => ({
+            index: messageKey.index,
+            cipherKey: messageKey.cipherKey,
+            macKey: messageKey.macKey,
+            iv: messageKey.iv
+        }))
+    };
+}
+function decodeSignalMessageKey(messageKey, field) {
+    const cipherKey = (0, coercion_1.asBytes)(messageKey.cipherKey, `${field}.cipherKey`);
+    if (cipherKey.byteLength !== 32) {
+        throw new Error(`invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
+    }
+    const macKey = (0, coercion_1.asBytes)(messageKey.macKey, `${field}.macKey`);
+    if (macKey.byteLength !== 32) {
+        throw new Error(`invalid ${field}.macKey length ${macKey.byteLength}`);
+    }
+    const iv = (0, coercion_1.asBytes)(messageKey.iv, `${field}.iv`);
+    if (iv.byteLength !== 16) {
+        throw new Error(`invalid ${field}.iv length ${iv.byteLength}`);
+    }
+    return {
+        index: (0, coercion_1.asNumber)(messageKey.index, `${field}.index`),
+        cipherKey,
+        macKey,
+        iv
+    };
+}
+function decodeSignalRecvChain(chain, field) {
+    const chainKey = chain.chainKey;
+    if (!chainKey) {
+        throw new Error(`missing ${field}.chainKey`);
+    }
+    const ratchetPubKey = (0, coercion_1.asBytes)(chain.senderRatchetKey, `${field}.senderRatchetKey`);
+    if (ratchetPubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
+    }
+    const chainKeyBytes = (0, coercion_1.asBytes)(chainKey.key, `${field}.chainKey.key`);
+    if (chainKeyBytes.byteLength !== 32) {
+        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
+    }
+    return {
+        ratchetPubKey,
+        nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
+        chainKey: chainKeyBytes,
+        unusedMsgKeys: (chain.messageKeys ?? []).map((messageKey, index) => decodeSignalMessageKey(messageKey, `${field}.messageKeys[${index}]`))
+    };
+}
+function decodeSignalSendChain(chain, field) {
+    const chainKey = chain.chainKey;
+    if (!chainKey) {
+        throw new Error(`missing ${field}.chainKey`);
+    }
+    const privateKey = (0, coercion_1.asOptionalBytes)(chain.senderRatchetKeyPrivate, `${field}.senderRatchetKeyPrivate`);
+    if (!privateKey) {
+        throw new Error(`missing ${field}.senderRatchetKeyPrivate`);
+    }
+    if (privateKey.byteLength !== 32) {
+        throw new Error(`invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
+    }
+    const ratchetPubKey = (0, coercion_1.asBytes)(chain.senderRatchetKey, `${field}.senderRatchetKey`);
+    if (ratchetPubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
+    }
+    const chainKeyBytes = (0, coercion_1.asBytes)(chainKey.key, `${field}.chainKey.key`);
+    if (chainKeyBytes.byteLength !== 32) {
+        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
+    }
+    return {
+        ratchetKey: {
+            pubKey: ratchetPubKey,
+            privKey: privateKey
+        },
+        nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
+        chainKey: chainKeyBytes
+    };
+}
+function decodeSignalSessionSnapshot(session, field) {
+    const senderChain = session.senderChain;
+    if (!senderChain) {
+        throw new Error(`missing ${field}.senderChain`);
+    }
+    const pendingPreKey = session.pendingPreKey;
+    const localPubKey = (0, coercion_1.asBytes)(session.localIdentityPublic, `${field}.localIdentityPublic`);
+    if (localPubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
+    }
+    const remotePubKey = (0, coercion_1.asBytes)(session.remoteIdentityPublic, `${field}.remoteIdentityPublic`);
+    if (remotePubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
+    }
+    const rootKey = (0, coercion_1.asBytes)(session.rootKey, `${field}.rootKey`);
+    if (rootKey.byteLength !== 32) {
+        throw new Error(`invalid ${field}.rootKey length ${rootKey.byteLength}`);
+    }
+    const localOneTimePubKey = pendingPreKey
+        ? (0, coercion_1.asBytes)(pendingPreKey.baseKey, `${field}.pendingPreKey.baseKey`)
+        : null;
+    if (localOneTimePubKey && localOneTimePubKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
+    }
+    const aliceBaseKey = (0, coercion_1.asOptionalBytes)(session.aliceBaseKey, `${field}.aliceBaseKey`) ?? null;
+    if (aliceBaseKey && aliceBaseKey.byteLength !== 33) {
+        throw new Error(`invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
+    }
+    return {
+        local: {
+            regId: (0, coercion_1.asNumber)(session.localRegistrationId, `${field}.localRegistrationId`),
+            pubKey: localPubKey
+        },
+        remote: {
+            regId: (0, coercion_1.asNumber)(session.remoteRegistrationId, `${field}.remoteRegistrationId`),
+            pubKey: remotePubKey
+        },
+        rootKey,
+        sendChain: decodeSignalSendChain(senderChain, `${field}.senderChain`),
+        recvChains: (session.receiverChains ?? []).map((chain, index) => decodeSignalRecvChain(chain, `${field}.receiverChains[${index}]`)),
+        initialExchangeInfo: pendingPreKey
+            ? {
+                remoteOneTimeId: (0, coercion_1.asOptionalNumber)(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
+                    null,
+                remoteSignedId: (0, coercion_1.asNumber)(pendingPreKey.signedPreKeyId, `${field}.pendingPreKey.signedPreKeyId`),
+                localOneTimePubKey: localOneTimePubKey
+            }
+            : null,
+        prevSendChainHighestIndex: (0, coercion_1.asOptionalNumber)(session.previousCounter, `${field}.previousCounter`) ?? 0,
+        aliceBaseKey
+    };
+}
+function encodeSignalSessionRecord(record) {
+    return _proto_1.proto.RecordStructure.encode({
+        currentSession: encodeSignalSessionSnapshot(record),
+        previousSessions: record.prevSessions.map((session) => encodeSignalSessionSnapshot(session))
+    }).finish();
+}
+function decodeSignalSessionRecord(raw) {
+    const decoded = _proto_1.proto.RecordStructure.decode((0, coercion_1.asBytes)(raw, 'signal_sessions.record'));
+    if (!decoded.currentSession) {
+        throw new Error('missing signal_sessions.record.currentSession');
+    }
+    const current = decodeSignalSessionSnapshot(decoded.currentSession, 'signal_sessions.currentSession');
+    return {
+        ...current,
+        prevSessions: (decoded.previousSessions ?? []).map((session, index) => decodeSignalSessionSnapshot(session, `signal_sessions.previousSessions[${index}]`))
+    };
+}
+function encodeSenderKeyRecord(record) {
+    return _proto_1.proto.SenderKeyRecordStructure.encode({
+        senderKeyStates: [
+            {
+                senderKeyId: record.keyId,
+                senderChainKey: {
+                    iteration: record.iteration,
+                    seed: record.chainKey
+                },
+                senderSigningKey: {
+                    public: record.signingPublicKey,
+                    private: record.signingPrivateKey
+                },
+                senderMessageKeys: (record.unusedMessageKeys ?? []).map((messageKey) => ({
+                    iteration: messageKey.iteration,
+                    seed: messageKey.seed
+                }))
+            }
+        ]
+    }).finish();
+}
+function decodeSenderKeyState(state, field) {
+    if (!state.senderChainKey) {
+        throw new Error(`missing ${field}.senderChainKey`);
+    }
+    if (!state.senderSigningKey) {
+        throw new Error(`missing ${field}.senderSigningKey`);
+    }
+    return {
+        keyId: (0, coercion_1.asNumber)(state.senderKeyId, `${field}.senderKeyId`),
+        iteration: (0, coercion_1.asNumber)(state.senderChainKey.iteration, `${field}.senderChainKey.iteration`),
+        chainKey: (0, coercion_1.asBytes)(state.senderChainKey.seed, `${field}.senderChainKey.seed`),
+        signingPublicKey: (0, coercion_1.asBytes)(state.senderSigningKey.public, `${field}.senderSigningKey.public`),
+        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`)
+        }))
+    };
+}
+function decodeSenderKeyRecord(raw, groupId, sender) {
+    const decoded = _proto_1.proto.SenderKeyRecordStructure.decode((0, coercion_1.asBytes)(raw, 'sender_keys.record'));
+    const state = decoded.senderKeyStates?.[0];
+    if (!state) {
+        throw new Error('missing sender_keys.record.senderKeyStates[0]');
+    }
+    const parsed = decodeSenderKeyState(state, 'sender_keys.record.senderKeyStates[0]');
+    return {
+        groupId,
+        sender,
+        keyId: parsed.keyId,
+        iteration: parsed.iteration,
+        chainKey: parsed.chainKey,
+        signingPublicKey: parsed.signingPublicKey,
+        signingPrivateKey: parsed.signingPrivateKey,
+        unusedMessageKeys: parsed.unusedMessageKeys
+    };
+}
+function decodeSenderKeyDistributionRow(row) {
+    return {
+        groupId: (0, coercion_1.asString)(row.group_id, 'sender_key_distribution.group_id'),
+        sender: {
+            user: (0, coercion_1.asString)(row.sender_user, 'sender_key_distribution.sender_user'),
+            server: (0, coercion_1.asString)(row.sender_server, 'sender_key_distribution.sender_server'),
+            device: (0, coercion_1.asNumber)(row.sender_device, 'sender_key_distribution.sender_device')
+        },
+        keyId: (0, coercion_1.asNumber)(row.key_id, 'sender_key_distribution.key_id'),
+        timestampMs: (0, coercion_1.asNumber)(row.timestamp_ms, 'sender_key_distribution.timestamp_ms')
+    };
+}
+function decodeSqliteCount(row, field) {
+    return row ? (0, coercion_1.asNumber)(row.count, field) : 0;
+}
+function decodeSignalRemoteIdentity(raw) {
+    return (0, coercion_1.asBytes)(raw, 'signal_identity.identity_key');
+}

package/dist/signal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/appstate.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/auth.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/contact.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/device-list.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/message.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/participants.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/retry.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/sender-key.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/signal.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/contracts/thread.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });