core-3nweb-client-lib 0.49.6 → 0.49.8

package/build/core/keyring/peer-keys/dataset/v2/peer-keys-db.js

@@ -0,0 +1,543 @@
+"use strict";
+/*
+ Copyright (C) 2026 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePeerKeysDB = makePeerKeysDB;
+const canonical_address_1 = require("../../../../../lib-common/canonical-address");
+const for_sqlite_1 = require("../../../../../lib-sqlite-on-3nstorage/for-sqlite");
+const lib_sqlite_on_3nstorage_1 = require("../../../../../lib-sqlite-on-3nstorage");
+const json_files_1 = require("../v1/json-files");
+const common_1 = require("../../../common");
+const rng_def_1 = require("../../../../../lib-common/rng-def");
+const buffer_utils_1 = require("../../../../../lib-common/buffer-utils");
+const ecma_nacl_1 = require("ecma-nacl");
+const number_line_1 = require("../../../../../lib-common/number-line");
+const logs_1 = require("./logs");
+const queryToCreatePeerKeysDbV2 = [
+    // XXX although we put foreign key into create clauses, current library binary is ignoring it even with pragma on
+    //     yet, we follow connection accordingly
+    // `--sql
+    // PRAGMA foreign_keys = ON
+    // `,
+    `--sql
+  CREATE TABLE peers (
+    peerCAddr TEXT NOT NULL PRIMARY KEY,
+    peerAddr TEXT NOT NULL
+  )
+  `,
+    // sending_key_pairs contains material for sending messages.
+    // Sending pair is suggested by peer.
+    `--sql
+  CREATE TABLE sending_key_pairs (
+    peerCAddr TEXT NOT NULL PRIMARY KEY REFERENCES peers ON DELETE CASCADE,
+    --
+    pairAlg TEXT NOT NULL,
+    pairTS INTEGER NOT NULL,
+    --
+    sentMsgsCount INTEGER,
+    sentMsgLastTS INTEGER,
+    --
+    peerPKey BLOB NOT NULL,
+    peerKId TEXT NOT NULL,
+    --
+    pids TEXT NOT NULL,
+    --
+    senderSKey BLOB NOT NULL,
+    senderPKey TEXT NOT NULL,
+    senderKId TEXT NOT NULL,
+    --
+    msgMasterKeyAlg TEXT NOT NULL,
+    msgMasterKey BLOB NOT NULL
+  )
+  `,
+    // reception_key_pairs are used for reading incoming messages.
+    // Reception pairs are suggested by this side to respective peers, ratcheting/updating keys of both sides.
+    // When peer encrypts message to a new pair, it implies that pair is ratcheted to be in use, making current
+    // pair old, and allowing to suggest next new pair, advancing key ratcheting.
+    // In a scenario when this side starts messaging, it suggests pairs with peer's introductory key, known at the
+    // time. Introductory key may change in time, resulting in different suggested pairs before peer ever replies.
+    // These pairs should be kept till peer replies, implying which pair is used, allowing to drop other ones.
+    `--sql
+  CREATE TABLE reception_key_pairs (
+    peerCAddr TEXT NOT NULL REFERENCES peers ON DELETE CASCADE,
+    ratchetStage TEXT NOT NULL,
+    pids TEXT NOT NULL,
+    --
+    pairAlg TEXT NOT NULL,
+    pairTS INTEGER NOT NULL,
+    --
+    receivedMsgsCounts TEXT,
+    receivedMsgLastTS INTEGER,
+    --
+    peerPKey BLOB NOT NULL,
+    peerKId TEXT NOT NULL,
+    isPeerIntroKey INTEGER NOT NULL,
+    --
+    recipientSKey BLOB NOT NULL,
+    recipientPKey TEXT NOT NULL,
+    recipientKId TEXT NOT NULL,
+    --
+    msgMasterKeyAlg TEXT NOT NULL,
+    msgMasterKey BLOB NOT NULL,
+    --
+    PRIMARY KEY (peerCAddr, recipientKId, peerKId),
+    UNIQUE (peerCAddr, recipientKId) ON CONFLICT FAIL
+  )
+  `,
+    `--sql
+  CREATE INDEX reception_pair_stage ON reception_key_pairs (peerCAddr, ratchetStage)
+  `,
+    `--sql
+  CREATE TABLE reception_key_pairs_pids (
+    peerCAddr TEXT NOT NULL,
+    peerKId TEXT NOT NULL,
+    recipientKId TEXT NOT NULL,
+    pid TEXT NOT NULL,
+    PRIMARY KEY (peerCAddr, recipientKId, peerKId, pid),
+    FOREIGN KEY (peerCAddr, recipientKId, peerKId) REFERENCES reception_key_pairs ON DELETE CASCADE
+  )
+  `,
+    `--sql
+  CREATE INDEX pid_to_reception_pair ON reception_key_pairs_pids (pid)
+  `
+].join(';\n');
+const sendingKeyPairsTabFields = {
+    peerCAddr: 'as-is',
+    pairAlg: 'as-is',
+    pairTS: 'as-is',
+    sentMsgsCount: 'as-is',
+    sentMsgLastTS: 'as-is',
+    peerPKey: 'as-is',
+    peerKId: 'as-is',
+    pids: for_sqlite_1.jsonTransform,
+    senderSKey: 'as-is',
+    senderPKey: 'as-is',
+    senderKId: 'as-is',
+    msgMasterKey: 'as-is',
+    msgMasterKeyAlg: 'as-is'
+};
+const receptionKeyPairsTabFields = {
+    peerCAddr: 'as-is',
+    ratchetStage: 'as-is',
+    pids: for_sqlite_1.jsonTransform,
+    pairTS: 'as-is',
+    pairAlg: 'as-is',
+    receivedMsgsCounts: for_sqlite_1.optJsonTransform,
+    receivedMsgLastTS: 'as-is',
+    peerPKey: 'as-is',
+    peerKId: 'as-is',
+    isPeerIntroKey: for_sqlite_1.booleanTransform,
+    recipientSKey: 'as-is',
+    recipientPKey: 'as-is',
+    recipientKId: 'as-is',
+    msgMasterKey: 'as-is',
+    msgMasterKeyAlg: 'as-is'
+};
+const pidsIndexTabFields = {
+    peerCAddr: 'as-is',
+    peerKId: 'as-is',
+    recipientKId: 'as-is',
+    pid: 'as-is'
+};
+const PEER_KEYS_DB = `peer-keys.sqlite`;
+const PEER_KEYS_DB_ATTR = `msg-index-db`;
+async function setMsgIndexInfoIntoAttrOf(dbFile, info) {
+    const completeInfo = {
+        dbVersion: 1,
+        ...info
+    };
+    await dbFile.updateXAttrs({
+        set: { [PEER_KEYS_DB_ATTR]: completeInfo }
+    });
+}
+async function readOrInitializeDB(dbsFS) {
+    if (await dbsFS.checkFilePresence(PEER_KEYS_DB)) {
+        const dbFile = await dbsFS.writableFile(PEER_KEYS_DB, { create: false });
+        return await lib_sqlite_on_3nstorage_1.SQLiteOn3NStorage.makeSynced(dbFile);
+    }
+    else {
+        const dbFile = await dbsFS.writableFile(PEER_KEYS_DB, { create: true, exclusive: true });
+        const peerKeys = await lib_sqlite_on_3nstorage_1.SQLiteOn3NStorage.makeSynced(dbFile);
+        peerKeys.db.run(queryToCreatePeerKeysDbV2);
+        await setMsgIndexInfoIntoAttrOf(peerKeys.dbFile, {});
+        await peerKeys.saveToFile();
+        await peerKeys.dbFileSync.upload();
+        await dbsFS.v.sync.upload('');
+        return peerKeys;
+    }
+}
+async function generatePids(random) {
+    const pids = [];
+    for (let i = 0; i < 5; i += 1) {
+        pids[i] = await (0, rng_def_1.stringOfB64UrlSafeChars)(common_1.PID_LENGTH, random);
+        if (i > 0) {
+            if (pids.slice(0, i).includes(pids[i])) {
+                i -= 1;
+            }
+        }
+    }
+    return pids;
+}
+async function makePeerKeysDB(peerKeysFS, random) {
+    const keys = await readOrInitializeDB(peerKeysFS);
+    let needToSave = false;
+    function noteDbMotificationForFileSaving() {
+        if (!needToSave && (keys.db.getRowsModified() > 0)) {
+            needToSave = true;
+        }
+    }
+    async function saveIfNeeded() {
+        if (needToSave) {
+            await keys.saveToFile();
+        }
+    }
+    function addPeer(peerAddr) {
+        const peerCAddr = (0, canonical_address_1.toCanonicalAddress)(peerAddr);
+        keys.db.exec(`--sql
+      INSERT INTO peers (peerCAddr, peerAddr) VALUES ($peerCAddr, $peerAddr) ON CONFLICT DO NOTHING`, { $peerCAddr: peerCAddr, $peerAddr: peerAddr });
+        noteDbMotificationForFileSaving();
+    }
+    function getSendingPair(peerCAddr) {
+        const pair = (0, for_sqlite_1.selectFromTable)(keys.db, 'sending_key_pairs', '*', { peerCAddr }, sendingKeyPairsTabFields);
+        return (pair ? pair[0] : undefined);
+    }
+    function addSendingPair(pair) {
+        (0, for_sqlite_1.performTableInsert)(keys.db, 'sending_key_pairs', pair, sendingKeyPairsTabFields);
+        noteDbMotificationForFileSaving();
+    }
+    function updateSendingPair(pair) {
+        (0, for_sqlite_1.updateInTable)(keys.db, 'sending_key_pairs', (0, for_sqlite_1.passOmitting)(pair, 'peerCAddr'), { peerCAddr: pair.peerCAddr }, sendingKeyPairsTabFields);
+        noteDbMotificationForFileSaving();
+    }
+    function updateSentMsgCountInSendingPair(peerCAddr, sentMsgsCount) {
+        updateSendingPair({ peerCAddr, sentMsgLastTS: Date.now(), sentMsgsCount });
+    }
+    function updateSendingPairFromSuggested(peerCAddr, pair, cryptoMaterial) {
+        updateSendingPair({
+            ...cryptoMaterial,
+            peerCAddr,
+            pids: pair.pids,
+            pairTS: pair.timestamp,
+            peerKId: pair.recipientPKey.kid,
+            sentMsgsCount: 0,
+            sentMsgLastTS: 0
+        });
+    }
+    function addSendingPairFromSuggested(peerCAddr, pair, cryptoMaterial) {
+        addSendingPair({
+            ...cryptoMaterial,
+            peerCAddr,
+            pids: pair.pids,
+            pairTS: pair.timestamp,
+            peerKId: pair.recipientPKey.kid,
+            sentMsgsCount: 0,
+            sentMsgLastTS: 0
+        });
+    }
+    function findKeyToMatchSuggestedForSendingPair(peerCAddr, thisSideKid) {
+        const pairs = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', ['ratchetStage', 'recipientSKey', 'recipientPKey', 'pairAlg'], { peerCAddr, recipientKId: thisSideKid }, receptionKeyPairsTabFields);
+        if (pairs) {
+            return {
+                pkey: pairs[0].recipientPKey,
+                skey: pairs[0].recipientSKey,
+                pairAlg: pairs[0].pairAlg
+            };
+        }
+    }
+    function getPeerAddressForCanonical(peerCAddr) {
+        const res = keys.db.exec(`--sql
+      SELECT peerAddr FROM peers WHERE peerCAddr=$peerCAddr`, { '$peerCAddr': peerCAddr });
+        return ((res.length > 0) ? (0, lib_sqlite_on_3nstorage_1.objectFromQueryExecResult)(res[0])[0].peerAddr : undefined);
+    }
+    function addReceptionPair(pair) {
+        (0, for_sqlite_1.performTableInsert)(keys.db, 'reception_key_pairs', pair, receptionKeyPairsTabFields);
+        const { peerCAddr, peerKId, pids, recipientKId } = pair;
+        for (const pid of pids) {
+            (0, for_sqlite_1.performTableInsert)(keys.db, 'reception_key_pairs_pids', { peerCAddr, peerKId, pid, recipientKId }, pidsIndexTabFields);
+        }
+        noteDbMotificationForFileSaving();
+    }
+    function markPairAsInUse(peerCAddr, peerKId, recipientKId) {
+        var _a;
+        const suggested = getPairSuggestedToPeer(peerCAddr);
+        if (((suggested === null || suggested === void 0 ? void 0 : suggested.senderKid) !== peerKId) || ((suggested === null || suggested === void 0 ? void 0 : suggested.recipientPKey.kid) !== recipientKId)) {
+            return false;
+        }
+        (0, for_sqlite_1.updateInTable)(keys.db, 'reception_key_pairs', { ratchetStage: 'old' }, { peerCAddr, ratchetStage: 'in_use' }, receptionKeyPairsTabFields);
+        (0, for_sqlite_1.updateInTable)(keys.db, 'reception_key_pairs', { ratchetStage: 'in_use' }, { peerCAddr, peerKId, recipientKId }, receptionKeyPairsTabFields);
+        const veryOld = (_a = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', ['peerKId', 'recipientKId', 'pairTS'], { peerCAddr, ratchetStage: 'old' }, receptionKeyPairsTabFields)) === null || _a === void 0 ? void 0 : _a.sort((a, b) => (b.pairTS - a.pairTS)).slice(1);
+        if (veryOld && (veryOld.length > 1)) {
+            for (const { recipientKId, peerKId } of veryOld) {
+                const whereParams = (0, for_sqlite_1.queryParamsFrom)({ peerCAddr, recipientKId, peerKId }, receptionKeyPairsTabFields);
+                const whereClause = (0, for_sqlite_1.andEqualExprFor)(whereParams);
+                keys.db.exec(`--sql
+          DELETE FROM reception_key_pairs WHERE ${whereClause}`, whereParams);
+            }
+        }
+        noteDbMotificationForFileSaving();
+        return true;
+    }
+    function updateReceivedMsgCountIn(peerCAddr, peerKId, recipientKId, msgCount, msgTS) {
+        const pair = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', ['receivedMsgLastTS', 'receivedMsgsCounts'], { peerCAddr, peerKId, recipientKId }, receptionKeyPairsTabFields);
+        if (!pair) {
+            return;
+        }
+        let { receivedMsgLastTS, receivedMsgsCounts } = pair[0];
+        if (!(0, number_line_1.addToNumberLineSegments)(receivedMsgsCounts, msgCount)) {
+            return;
+        }
+        (0, for_sqlite_1.updateInTable)(keys.db, 'reception_key_pairs', { receivedMsgsCounts, receivedMsgLastTS: Math.max(receivedMsgLastTS, msgTS) }, { peerCAddr, peerKId, recipientKId }, receptionKeyPairsTabFields);
+        noteDbMotificationForFileSaving();
+    }
+    function findReceptionPairsForPId(pid) {
+        const keyIds = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs_pids', ['peerCAddr', 'peerKId', 'recipientKId'], { pid }, pidsIndexTabFields);
+        if (!keyIds) {
+            return;
+        }
+        const foundPairs = [];
+        for (const { peerCAddr, peerKId, recipientKId } of keyIds) {
+            const key = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', ['msgMasterKey', 'ratchetStage', 'pairAlg'], { peerCAddr, peerKId, recipientKId }, receptionKeyPairsTabFields);
+            const { msgMasterKey, ratchetStage, pairAlg } = key[0];
+            foundPairs.push({
+                msgMasterKey: msgMasterKey, pairAlg: pairAlg, peerCAddr: peerCAddr,
+                peerKId: peerKId, ratchetStage: ratchetStage, recipientKId: recipientKId
+            });
+        }
+        return ((foundPairs.length > 0) ? foundPairs : undefined);
+    }
+    async function absorbV1DataIfPresent(keyringFS) {
+        var _a;
+        const v1Entries = await (0, json_files_1.checkIfV1AndReadPeerKeys)(keyringFS);
+        if (v1Entries)
+            for (const peer of v1Entries) {
+                const peerCAddr = (0, canonical_address_1.toCanonicalAddress)(peer.correspondent);
+                addPeer(peer.correspondent);
+                if (peer.receptionPairs.suggested) {
+                    addReceptionPair((0, json_files_1.v1ReceptionPairToV2RecipientKeyPairDbEntry)(peer.receptionPairs.suggested, 'suggested', peerCAddr));
+                }
+                if (peer.receptionPairs.inUse) {
+                    addReceptionPair((0, json_files_1.v1ReceptionPairToV2RecipientKeyPairDbEntry)(peer.receptionPairs.inUse, 'in_use', peerCAddr));
+                }
+                if (peer.receptionPairs.old) {
+                    addReceptionPair((0, json_files_1.v1ReceptionPairToV2RecipientKeyPairDbEntry)(peer.receptionPairs.old, 'old', peerCAddr));
+                }
+                if (((_a = peer.sendingPair) === null || _a === void 0 ? void 0 : _a.type) === 'ratcheted') {
+                    addSendingPair((0, json_files_1.v1RatchetedSendingPairToV2SendingKeyPairDbEntry)(peer.sendingPair, peerCAddr));
+                }
+            }
+        await keys.saveToFile();
+        await keys.dbFileSync.upload();
+    }
+    function getPairSuggestedToPeer(peerCAddr) {
+        const pairs = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', ['pids', 'isPeerIntroKey', 'peerKId', 'pairTS', 'recipientKId', 'recipientPKey'], { peerCAddr, ratchetStage: 'suggested' }, receptionKeyPairsTabFields);
+        if (!pairs) {
+            return;
+        }
+        const { pids, peerKId, pairTS, recipientKId, recipientPKey } = pairs[0];
+        return {
+            pids: pids,
+            recipientPKey: {
+                kid: recipientKId,
+                k: recipientPKey
+            },
+            timestamp: pairTS,
+            senderKid: peerKId
+        };
+    }
+    async function generateSuggestedPairOnPeerIntroKey(peerCAddr, peerIntroPKey) {
+        const { kid: peerKId, k: peerPKey } = peerIntroPKey;
+        return await generateAndAddSuggestedPair(peerCAddr, peerKId, buffer_utils_1.base64.open(peerPKey), false);
+    }
+    async function generateAndAddSuggestedPair(peerCAddr, peerKId, peerPKey, isPeerIntroKey) {
+        const recipientKey = await (0, common_1.generateKeyPair)(random);
+        const recipientSKey = buffer_utils_1.base64.open(recipientKey.skey.k);
+        const msgMasterKey = ecma_nacl_1.box.calc_dhshared_key(peerPKey, recipientSKey);
+        const pids = await generatePids(random);
+        const pairTS = Date.now();
+        const dbEntry = {
+            peerCAddr,
+            ratchetStage: 'suggested',
+            pids,
+            pairTS,
+            pairAlg: recipientKey.skey.alg,
+            isPeerIntroKey,
+            peerKId,
+            peerPKey,
+            recipientKId: recipientKey.pkey.kid,
+            recipientPKey: recipientKey.pkey.k,
+            recipientSKey,
+            msgMasterKey,
+            msgMasterKeyAlg: ecma_nacl_1.secret_box.JWK_ALG_NAME,
+            receivedMsgLastTS: null,
+            receivedMsgsCounts: []
+        };
+        addReceptionPair(dbEntry);
+        noteDbMotificationForFileSaving();
+        return {
+            nextCrypto: {
+                pids,
+                recipientPKey: {
+                    kid: recipientKey.pkey.kid,
+                    k: recipientKey.pkey.k
+                },
+                senderKid: peerKId,
+                timestamp: pairTS
+            },
+            entryToLog: dbEntry
+        };
+    }
+    async function generateRegularSuggestedPairIfNeeded(peerCAddr) {
+        const pairsInUse = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', ['pairTS'], { peerCAddr, ratchetStage: 'in_use' }, receptionKeyPairsTabFields);
+        if (pairsInUse && ((pairsInUse[0].pairTS + common_1.MIN_PERIOD_FOR_PAIR) > Date.now())) {
+            return;
+        }
+        const sendingPair = getSendingPair(peerCAddr);
+        if (!sendingPair) {
+            throw new Error(`Regular sending pair should be present to use peer's key in next suggested crypto`);
+        }
+        const { peerKId, peerPKey } = sendingPair;
+        return await generateAndAddSuggestedPair(peerCAddr, peerKId, peerPKey, false);
+    }
+    function getPeerKeysInfo(peerAddr) {
+        var _a;
+        const peerCAddr = (0, canonical_address_1.toCanonicalAddress)(peerAddr);
+        const sp = getSendingPair(peerCAddr);
+        const rpSuggested = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', '*', { peerCAddr, ratchetStage: 'suggested' }, receptionKeyPairsTabFields);
+        const rpInUse = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', '*', { peerCAddr, ratchetStage: 'in_use' }, receptionKeyPairsTabFields);
+        const rpOld = (_a = (0, for_sqlite_1.selectFromTable)(keys.db, 'reception_key_pairs', '*', { peerCAddr, ratchetStage: 'old' }, receptionKeyPairsTabFields)) === null || _a === void 0 ? void 0 : _a.sort((a, b) => (b.pairTS - a.pairTS));
+        return {
+            sendingPair: (sp ? {
+                alg: sp.pairAlg,
+                pids: sp.pids,
+                type: 'ratcheted',
+                timestamp: sp.pairTS,
+                senderKId: sp.senderKId,
+                recipientKId: sp.peerKId,
+                sentMsgs: {
+                    count: sp.sentMsgsCount,
+                    lastTS: sp.sentMsgLastTS
+                }
+            } : null),
+            receptionPairs: {
+                suggested: (rpSuggested ? recipientKeyPairDbEntryIntoDisplayInfo(rpSuggested[0]) : null),
+                inUse: (rpInUse ? recipientKeyPairDbEntryIntoDisplayInfo(rpInUse[0]) : null),
+                old: (rpOld ? recipientKeyPairDbEntryIntoDisplayInfo(rpOld[0]) : null)
+            }
+        };
+    }
+    async function saveAndSync() {
+        await saveIfNeeded();
+        const syncedIndexDbVersion = await keys.dbFileSync.upload();
+        return syncedIndexDbVersion;
+    }
+    // XXX at a startup we should check if current local latest is too old
+    // XXX one should watch for reconnect event and run similar checks of possibly missed events
+    async function absorbOpsFromOtherDevices(changeProc, ops) {
+        await changeProc.startOrChain(async () => {
+            for (const op of ops) {
+                if (op.p) {
+                    if (op.p.opType === 'pair-from-peer') {
+                        const { peerAddr, sendingPairRecord: inJSON } = op.p;
+                        const existingPair = getSendingPair(inJSON.peerCAddr);
+                        if (existingPair) {
+                            if (existingPair.pairTS < inJSON.pairTS) {
+                                updateSendingPair((0, logs_1.sendingPairEntryFromJSON)(inJSON));
+                            }
+                        }
+                        else {
+                            if (!getPeerAddressForCanonical(inJSON.peerCAddr)) {
+                                addPeer(peerAddr);
+                            }
+                            addSendingPair((0, logs_1.sendingPairEntryFromJSON)(inJSON));
+                        }
+                    }
+                    else if (op.p.opType === 'pair-suggested-to-peer') {
+                        const { peerAddr, receivingPairRecord: inJSON } = op.p;
+                        const existingPair = getPairSuggestedToPeer(inJSON.peerCAddr);
+                        if (existingPair) {
+                            if (existingPair.timestamp < inJSON.pairTS) {
+                                // XXX replace existingPair with one from inJSON
+                                //  let's note that in broken situation we may suggest fixing moves
+                            }
+                        }
+                        else {
+                            if (!getPeerAddressForCanonical(inJSON.peerCAddr)) {
+                                addPeer(peerAddr);
+                            }
+                            addReceptionPair((0, logs_1.recipientPairEntryFromJSON)(inJSON));
+                        }
+                    }
+                    else if (op.p.opType === 'peer-started-using-pair') {
+                        const { peerCAddr, peerKId, recipientKId } = op.p;
+                        markPairAsInUse(peerCAddr, peerKId, recipientKId);
+                    }
+                }
+                else if (op.syncPoint) {
+                    // XXX
+                }
+            }
+            await saveIfNeeded();
+        });
+    }
+    function watchAndApplyOpsFromOtherDevices(changeProc, resetSyncInterval) {
+        return keys.dbFile.watch({
+            next: fsEvent => changeProc.startOrChain(async () => {
+                if (fsEvent.type === 'remote-change') {
+                    // XXX get remote, compare,add to current what is missing, vs remote
+                    resetSyncInterval();
+                }
+            })
+        });
+    }
+    return {
+        saveIfNeeded,
+        generateSuggestedPairOnPeerIntroKey,
+        getPairSuggestedToPeer,
+        generateRegularSuggestedPairIfNeeded,
+        addPeer,
+        getSendingPair,
+        updateSentMsgCountInSendingPair,
+        addSendingPairFromSuggested,
+        updateSendingPairFromSuggested,
+        findKeyToMatchSuggestedForSendingPair,
+        addReceptionPair,
+        markPairAsInUse,
+        findReceptionPairsForPId,
+        absorbV1DataIfPresent,
+        getPeerAddressForCanonical,
+        updateReceivedMsgCountIn,
+        absorbOpsFromOtherDevices,
+        watchAndApplyOpsFromOtherDevices,
+        saveAndSync,
+        getPeerKeysInfo
+    };
+}
+function recipientKeyPairDbEntryIntoDisplayInfo(p) {
+    return {
+        alg: p.pairAlg,
+        pids: p.pids,
+        recipientKId: p.recipientKId,
+        senderKId: p.peerKId,
+        timestamp: p.pairTS,
+        isSenderIntroKey: p.isPeerIntroKey,
+        receivedMsgs: {
+            counts: p.receivedMsgsCounts,
+            lastTS: p.receivedMsgLastTS
+        }
+    };
+}
+Object.freeze(exports);

package/build/core/keyring/peer-keys/index.d.ts

@@ -0,0 +1,24 @@
+import { JWKeyPair, ASMailKeyPair } from '../common';
+import { SuggestedNextKeyPair } from '../../asmail/msg/opener';
+import { AsyncRNG } from '../../../lib-common/rng-def';
+import { Logger } from '../../../lib-client/logging/log-to-file';
+type WritableFS = web3n.files.WritableFS;
+type JsonKey = web3n.keys.JsonKey;
+export declare function makePeersKeyring(keyringFS: WritableFS, localFS: WritableFS, random: AsyncRNG, logger: Logger): Promise<{
+    getPeerAddressForCanonical: (peerCAddr: string) => string | undefined;
+    needIntroKeyFor: (peerAddr: string) => boolean;
+    suggestPairForPeerIntroKey: (peerAddr: string, peerIntroPKey: JsonKey) => Promise<SuggestedNextKeyPair>;
+    getSendingCryptoWithinEstablishedPair: (peerCAddr: string) => Promise<{
+        currentPair: ASMailKeyPair;
+        msgMasterKey: Uint8Array;
+        msgCount: number;
+        nextMsgCrypto?: SuggestedNextKeyPair;
+    }>;
+    absorbNextPairSuggestedByPeer: (peerAddr: string, pair: SuggestedNextKeyPair, introKey?: JWKeyPair) => Promise<void>;
+    findEstablishedReceptionPairs: (pid: string) => Pick<import("./dataset/v2/peer-keys-db").RecipientKeyPairDbEntry, "peerCAddr" | "peerKId" | "recipientKId" | "msgMasterKey" | "ratchetStage" | "pairAlg">[] | undefined;
+    markPairAsInUse: (peerCAddr: string, peerKId: string, recipientKId: string) => Promise<void>;
+    updateReceivedMsgCountIn: (peerCAddr: string, peerKId: string, recipientKId: string, msgCount: number, msgTS: number) => void;
+    close: () => Promise<void>;
+    getPeerKeysInfo: (peerAddr: string) => web3n.keys.CorrespondentKeysInfo | undefined;
+}>;
+export {};