core-3nweb-client-lib 0.49.5 → 0.49.7

package/build/core/asmail/index.js

@@ -49,7 +49,7 @@ class ASMail {
             this.keyring = keyring;
             await this.setupSendingParams(syncedFS);
             await Promise.all([
-                this.setupInbox(syncedFS, getSigner, getStorages, makeResolver),
+                this.setupInbox(syncedFS, localFS, getSigner, getStorages, makeResolver),
                 this.setupDelivery(localFS, getSigner, makeResolver)
             ]);
             await (0, fs_sync_utils_1.uploadFolderChangesIfAny)(syncedFS);
@@ -61,7 +61,7 @@ class ASMail {
         }
     }
     async setupSendingParams(syncedFS) {
-        const fs = await (0, fs_sync_utils_1.getOrMakeAndUploadFolderIn)(syncedFS, SEND_PARAMS_DATA_FOLDER);
+        const fs = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, SEND_PARAMS_DATA_FOLDER);
         this.sendingParams = await sending_params_1.SendingParamsHolder.makeAndInit(fs, this.config.makeParamSetterAndGetter('anon-sender/invites'), this.random);
     }
     async setupDelivery(localFS, getSigner, makeResolver) {
@@ -75,8 +75,8 @@ class ASMail {
             midResolver: makeResolver('mailerid', this.logger.logError),
             correspondents: {
                 needIntroKeyFor: this.keyring.needIntroKeyFor,
-                generateKeysToSend: this.keyring.generateKeysToSend,
-                nextCrypto: this.keyring.nextCrypto,
+                generateIntroKeysToSendMsg: this.keyring.generateIntroKeysToSendMsg,
+                getEstablishedKeysToSendMsg: this.keyring.getEstablishedKeysToSendMsg,
                 paramsForSendingTo: this.sendingParams.otherSides.get,
                 newParamsForSendingReplies: this.sendingParams.thisSide.getUpdated
             },
@@ -86,10 +86,11 @@ class ASMail {
             logWarning: this.logger.logWarning
         });
     }
-    async setupInbox(syncedFS, getSigner, getStorages, makeResolver) {
+    async setupInbox(syncedFS, localFS, getSigner, getStorages, makeResolver) {
         const cachePath = this.inboxPathForUser(this.address);
-        const inboxSyncedFS = await (0, fs_sync_utils_1.getOrMakeAndUploadFolderIn)(syncedFS, INBOX_DATA_FOLDER);
-        this.inbox = await inbox_1.InboxOnServer.makeAndStart(cachePath, inboxSyncedFS, {
+        const inboxSyncedFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, INBOX_DATA_FOLDER);
+        const inboxLocalFS = await localFS.writableSubRoot(INBOX_DATA_FOLDER);
+        this.inbox = await inbox_1.InboxOnServer.makeAndStart(cachePath, inboxSyncedFS, inboxLocalFS, {
             address: this.address,
             cryptor: this.cryptor,
             random: this.random,

package/build/core/asmail/msg/common.d.ts

@@ -38,7 +38,6 @@ export interface MsgEnvelope {
 export interface SuggestedNextKeyPair {
     pids: string[];
     senderKid: string;
-    isSenderIntroKey?: boolean;
     recipientPKey: JsonKeyShort;
     timestamp: number;
 }

package/build/core/asmail/msg/common.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2020, 2022 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 2020, 2022, 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

package/build/core/asmail/msg/packer.js

@@ -153,7 +153,7 @@ class MsgPacker {
             const fPath = appendedPath(fsPath, fName);
             if (entry.isFile) {
                 await fs.readonlyFile(fName);
-                this.addFileInto(folder, fName, fPath);
+                await this.addFileInto(folder, fName, fPath);
             }
             else if (entry.isFolder) {
                 const f = await fs.readonlySubRoot(fName);
@@ -331,8 +331,6 @@ class MsgPacker {
         if (this.hasAttachments) {
             this.main['Attachments'] = attachments;
         }
-        // DEBUG log
-        console.log(` message packer allObjs has ${this.allObjs.size} items`);
     }
     throwupOnMissingParts() {
         if (!this.meta) {

package/build/core/index.js

@@ -38,12 +38,12 @@ class Core {
         this.appDirs = appDirs;
         this.logger = logger;
         this.signUpUrl = signUpUrl;
+        this.keyrings = undefined;
         this.idManager = undefined;
         this.closingProc = undefined;
         this.isInitialized = false;
         this.cryptor = makeCryptor(this.logger.logError, this.logger.logWarning);
         this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.random, this.appDirs.storagePathFor);
-        this.keyrings = new keyring_1.Keyrings(this.cryptor.cryptor.sbox, this.random, this.logger);
         this.asmail = new asmail_1.ASMail(this.cryptor.cryptor.sbox, this.random, this.makeNet, this.appDirs.inboxPathFor, this.logger);
         Object.seal(this);
     }
@@ -265,9 +265,10 @@ class Core {
         }
     }
     makeKeyringsCAP(requestedCAPs) {
+        var _a;
         if (requestedCAPs.keyrings
             && (requestedCAPs.keyrings === 'all')) {
-            return this.keyrings.makeKeyringsCAP();
+            return (_a = this.keyrings) === null || _a === void 0 ? void 0 : _a.makeKeyringsCAP();
         }
         else {
             return undefined;
@@ -292,9 +293,10 @@ class Core {
     async close() {
         if (!this.closingProc) {
             this.closingProc = (async () => {
+                var _a;
                 if (this.isInitialized) {
                     await this.asmail.close();
-                    await this.keyrings.close();
+                    await ((_a = this.keyrings) === null || _a === void 0 ? void 0 : _a.close());
                     await this.storages.close();
                     this.asmail = undefined;
                     this.keyrings = undefined;
@@ -323,7 +325,8 @@ class Core {
             const asmailServerConfig = new config_1.ConfigOfASMailServer(address, getSigner, this.makeResolver('asmail', this.logger.logError), this.makeNet());
             emitBootEvent({ coreApp: constants_1.KEYRINGS_APP_NAME, message: `starting initialization` });
             const keyringsSyncedFS = await this.storages.makeSyncedFSForApp(constants_1.KEYRINGS_APP_NAME);
-            await this.keyrings.init(keyringsSyncedFS, this.idManager.getSigner, asmailServerConfig.makeParamSetterAndGetter('init-pub-key'));
+            const keyringsLocalFS = await this.storages.makeLocalFSForApp(constants_1.KEYRINGS_APP_NAME);
+            this.keyrings = await (0, keyring_1.makeKeyrings)(this.cryptor.cryptor.sbox, this.random, this.logger, keyringsSyncedFS, keyringsLocalFS, this.idManager.getSigner, asmailServerConfig.makeParamSetterAndGetter('init-pub-key'));
             emitBootEvent({ coreApp: constants_1.KEYRINGS_APP_NAME, message: `✔️  initialized` });
             emitBootEvent({ coreApp: constants_1.ASMAIL_APP_NAME, message: `starting initialization` });
             const inboxSyncedFS = await this.storages.makeSyncedFSForApp(constants_1.ASMAIL_APP_NAME);

package/build/core/keyring/common.d.ts

@@ -4,6 +4,7 @@ type JsonKeyShort = web3n.keys.JsonKeyShort;
 export type MsgKeyRole = 'suggested' | 'in_use' | 'old' | 'published_intro' | 'prev_published_intro' | 'introductory';
 export declare const KID_LENGTH = 16;
 export declare const PID_LENGTH = 2;
+export declare const MIN_PERIOD_FOR_PAIR: number;
 export interface JWKeyPair {
     skey: JsonKey;
     pkey: JsonKey;

package/build/core/keyring/common.js

@@ -16,7 +16,7 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KEY_USE = exports.PID_LENGTH = exports.KID_LENGTH = void 0;
+exports.KEY_USE = exports.MIN_PERIOD_FOR_PAIR = exports.PID_LENGTH = exports.KID_LENGTH = void 0;
 exports.generateKeyPair = generateKeyPair;
 exports.generateSymmetricKey = generateSymmetricKey;
 exports.extractSKeyBytes = extractSKeyBytes;
@@ -31,6 +31,7 @@ const buffer_utils_1 = require("../../lib-common/buffer-utils");
 const rng_def_1 = require("../../lib-common/rng-def");
 exports.KID_LENGTH = 16;
 exports.PID_LENGTH = 2;
+exports.MIN_PERIOD_FOR_PAIR = 15 * 60 * 1000;
 exports.KEY_USE = {
     PUBLIC: 'asmail-pub-key',
     SECRET: 'asmail-sec-key',

package/build/core/keyring/index.d.ts

@@ -1,4 +1,3 @@
-import { IdToEmailMap } from './id-to-email-map';
 import { MsgKeyRole } from './common';
 import { AsyncSBoxCryptor } from 'xsp-files';
 import { ResourcesForSending } from '../asmail/delivery/common';
@@ -28,49 +27,13 @@ type SendingResources = ResourcesForSending['correspondents'];
 type ReceptionResources = ResourcesForReceiving['correspondents'];
 export interface KeyringForASMail {
     needIntroKeyFor: SendingResources['needIntroKeyFor'];
-    generateKeysToSend: SendingResources['generateKeysToSend'];
-    nextCrypto: SendingResources['nextCrypto'];
+    generateIntroKeysToSendMsg: SendingResources['generateIntroKeysToSendMsg'];
+    getEstablishedKeysToSendMsg: SendingResources['getEstablishedKeysToSendMsg'];
     decrypt: ReceptionResources['msgDecryptor'];
     close(): Promise<void>;
 }
-export interface KeyPairsStorage {
-    pairIdToEmailMap: IdToEmailMap;
-    saveChanges: () => void;
-}
-export declare class Keyrings {
-    private readonly cryptor;
-    private readonly random;
-    private readonly logger;
-    /**
-     * This is a map from correspondents' canonical addresses to key objects.
-     */
-    private readonly corrKeys;
-    readonly pairIdToEmailMap: IdToEmailMap;
-    private readonly workLabel;
-    private storage;
-    private publishedKeys;
-    constructor(cryptor: AsyncSBoxCryptor, random: AsyncRNG, logger: Logger);
-    private readonly asKeyPairsStorage;
-    private addCorrespondent;
-    init(fs: WritableFS, getSigner: GetSigner, pkeyOnServer: ParamOnServer<'init-pub-key'>): Promise<void>;
-    forASMail(): KeyringForASMail;
-    private saveChanges;
-    private needIntroKeyFor;
-    private generateKeysToSend;
-    private nextCrypto;
-    private decryptMsgKeyWithIntroPair;
-    private findEstablishedReceptionPairs;
-    private decryptMsgKeyWithEstablishedPair;
-    /**
-     * This method updates message counts and a timestamp in a given reception
-     * pair.
-     * @param rp is a sending pair, in which changes should be done. Note this
-     * must be a shared structure at this point, not a copy of a pair.
-     * @param msgCount is a message count that should be added to the pair.
-     */
-    private updateReceivedMsgCountIn;
-    private absorbSuggestedNextKeyPair;
-    private decrypt;
-    close(): Promise<void>;
-    makeKeyringsCAP(): Service;
-}
+export declare function makeKeyrings(cryptor: AsyncSBoxCryptor, random: AsyncRNG, logger: Logger, fs: WritableFS, localFS: WritableFS, getSigner: GetSigner, pkeyOnServer: ParamOnServer<'init-pub-key'>): Promise<{
+    close: () => Promise<void>;
+    makeKeyringsCAP: () => Service;
+    forASMail: () => KeyringForASMail;
+}>;

package/build/core/keyring/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 2022, 2025 - 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
@@ -16,124 +16,54 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Keyrings = exports.KEY_USE = void 0;
-const correspondent_keys_1 = require("./correspondent-keys");
-const id_to_email_map_1 = require("./id-to-email-map");
+exports.KEY_USE = void 0;
+exports.makeKeyrings = makeKeyrings;
+const peer_keys_1 = require("./peer-keys");
 const common_1 = require("./common");
 const async_cryptor_wrap_1 = require("../../lib-common/async-cryptor-wrap");
 const xsp_files_1 = require("xsp-files");
-const buffer_utils_1 = require("../../lib-common/buffer-utils");
 const canonical_address_1 = require("../../lib-common/canonical-address");
-const common_2 = require("../asmail/delivery/common");
-const keyring_storage_1 = require("./keyring-storage");
 const cryptor_work_labels_1 = require("../../lib-client/cryptor-work-labels");
-const published_intro_key_1 = require("./published-intro-key");
-var common_3 = require("./common");
-Object.defineProperty(exports, "KEY_USE", { enumerable: true, get: function () { return common_3.KEY_USE; } });
-const FILE_FOR_INTRO_KEY_ON_SERVER = 'introductory-keys/published-on-server.json';
-// XXX Keyring is just a storage and crypto functionality around keys
-class Keyrings {
-    constructor(cryptor, random, logger) {
-        this.cryptor = cryptor;
-        this.random = random;
-        this.logger = logger;
-        /**
-         * This is a map from correspondents' canonical addresses to key objects.
-         */
-        this.corrKeys = new Map();
-        this.pairIdToEmailMap = new id_to_email_map_1.IdToEmailMap();
-        this.workLabel = cryptor_work_labels_1.cryptoWorkLabels.makeRandom('asmail');
-        this.storage = undefined;
-        this.publishedKeys = undefined;
-        this.asKeyPairsStorage = {
-            pairIdToEmailMap: this.pairIdToEmailMap,
-            saveChanges: this.saveChanges.bind(this)
-        };
-        Object.seal(this);
-    }
-    addCorrespondent(address, serialForm) {
-        const ck = (serialForm ?
-            new correspondent_keys_1.CorrespondentKeys(this.asKeyPairsStorage, this.random, undefined, serialForm) :
-            new correspondent_keys_1.CorrespondentKeys(this.asKeyPairsStorage, this.random, address));
-        if (this.corrKeys.has(ck.correspondent)) {
-            throw new Error(`Correspondent with address ${ck.correspondent} is already present.`);
-        }
-        this.corrKeys.set(ck.correspondent, ck);
-        if (serialForm) {
-            ck.mapAllKeysIntoRing();
-        }
-        return ck;
-    }
-    async init(fs, getSigner, pkeyOnServer) {
-        this.publishedKeys = await published_intro_key_1.PublishedIntroKey.makeAndInit(await fs.writableFile(FILE_FOR_INTRO_KEY_ON_SERVER), getSigner, this.random, pkeyOnServer);
-        this.storage = (0, keyring_storage_1.makeKeyringStorage)(fs);
-        await this.storage.start();
-        const serialForm = await this.storage.load();
-        if (serialForm) {
-            const json = JSON.parse(serialForm);
-            // TODO check json's fields
-            // init data
-            json.corrKeys.forEach((info) => {
-                this.addCorrespondent(undefined, info);
-            });
-        }
-        else {
-            // save initial file, as there was none initially
-            this.saveChanges();
-        }
-    }
-    forASMail() {
-        return {
-            close: this.close.bind(this),
-            decrypt: this.decrypt.bind(this),
-            generateKeysToSend: this.generateKeysToSend.bind(this),
-            needIntroKeyFor: this.needIntroKeyFor.bind(this),
-            nextCrypto: this.nextCrypto.bind(this),
-        };
-    }
-    saveChanges() {
-        // pack bytes that need to be encrypted and saved
-        const dataToSave = {
-            corrKeys: []
+const published_intro_key_1 = require("./introductory-keys/published-intro-key");
+const fs_sync_utils_1 = require("../../lib-client/fs-utils/fs-sync-utils");
+const ecma_nacl_1 = require("ecma-nacl");
+const buffer_utils_1 = require("../../lib-common/buffer-utils");
+var common_2 = require("./common");
+Object.defineProperty(exports, "KEY_USE", { enumerable: true, get: function () { return common_2.KEY_USE; } });
+const INTRO_KEYS_FOLDER = 'introductory-keys';
+const INTRO_KEY_ON_SERVER_FILE = `published-on-server.json`;
+async function makeKeyrings(cryptor, random, logger, fs, localFS, getSigner, pkeyOnServer) {
+    const workLabel = cryptor_work_labels_1.cryptoWorkLabels.makeRandom('asmail');
+    const introKeysFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(fs, INTRO_KEYS_FOLDER);
+    const publishedKeys = await (0, published_intro_key_1.makeHolderOfPublishedIntroKey)(await introKeysFS.writableFile(INTRO_KEY_ON_SERVER_FILE), getSigner, random, pkeyOnServer);
+    const peerKeys = await (0, peer_keys_1.makePeersKeyring)(fs, localFS, random, logger);
+    async function generateIntroKeysToSendMsg(address, introPKeyFromServer) {
+        if (introPKeyFromServer.alg !== ecma_nacl_1.box.JWK_ALG_NAME) {
+            // XXX make some standard runtime exception, for unknown alg
+            throw new Error(`Unknown alg in introductory key: ${introPKeyFromServer.alg}`);
+        }
+        const oneTime = await (0, common_1.generateKeyPair)(random);
+        const currentPair = {
+            recipientKid: introPKeyFromServer.kid,
+            senderPKey: oneTime.pkey
         };
-        for (const corrKeys of this.corrKeys.values()) {
-            dataToSave.corrKeys.push(corrKeys.serialForm());
-        }
-        // trigger saving utility
-        this.storage.save(JSON.stringify(dataToSave));
-    }
-    needIntroKeyFor(address) {
-        address = (0, canonical_address_1.toCanonicalAddress)(address);
-        return !this.corrKeys.has(address);
+        const msgMasterKey = ecma_nacl_1.box.calc_dhshared_key(buffer_utils_1.base64.open(introPKeyFromServer.k), buffer_utils_1.base64.open(oneTime.skey.k));
+        const nextNonce = await random(xsp_files_1.NONCE_LENGTH);
+        const encryptor = (0, async_cryptor_wrap_1.makeEncryptor)(cryptor, workLabel, msgMasterKey, nextNonce);
+        msgMasterKey.fill(0);
+        const nextMsgCrypto = await peerKeys.suggestPairForPeerIntroKey(address, introPKeyFromServer);
+        return { encryptor, currentPair, msgCount: 1, nextMsgCrypto };
     }
-    ;
-    async generateKeysToSend(address, introPKeyFromServer) {
-        address = (0, canonical_address_1.toCanonicalAddress)(address);
-        let ck = this.corrKeys.get(address);
-        if (!ck) {
-            if (!introPKeyFromServer) {
-                throw new Error(`There are no known keys for given address ${address} and a key from a mail server is not given either.`);
-            }
-            ck = this.addCorrespondent(address);
-        }
-        const { msgMasterKey, currentPair, msgCount } = await ck.getSendingPair(introPKeyFromServer);
+    async function getEstablishedKeysToSendMsg(address) {
+        const { msgMasterKey, currentPair, msgCount, nextMsgCrypto } = await peerKeys.getSendingCryptoWithinEstablishedPair((0, canonical_address_1.toCanonicalAddress)(address));
         // prepare message encryptor
-        const nextNonce = await this.random(xsp_files_1.NONCE_LENGTH);
-        const encryptor = (0, async_cryptor_wrap_1.makeEncryptor)(this.cryptor, this.workLabel, msgMasterKey, nextNonce);
+        const nextNonce = await random(xsp_files_1.NONCE_LENGTH);
+        const encryptor = (0, async_cryptor_wrap_1.makeEncryptor)(cryptor, workLabel, msgMasterKey, nextNonce);
         msgMasterKey.fill(0);
-        return { encryptor, currentPair, msgCount };
+        return { encryptor, currentPair, msgCount, nextMsgCrypto };
     }
-    async nextCrypto(address) {
-        address = (0, canonical_address_1.toCanonicalAddress)(address);
-        let ck = this.corrKeys.get(address);
-        if (!ck) {
-            throw new Error(`No correspondent keys found for ${address}`);
-        }
-        const suggestPair = await ck.suggestPair();
-        return suggestPair;
-    }
-    async decryptMsgKeyWithIntroPair(recipientKid, senderPKey, getMainObjHeader) {
-        const recipKey = this.publishedKeys.find(recipientKid);
+    async function decryptMsgKeyWithIntroPair(recipientKid, senderPKey, getMainObjHeader) {
+        const recipKey = publishedKeys.find(recipientKid);
         if (!recipKey) {
             return;
         }
@@ -142,16 +72,17 @@ class Keyrings {
         if (h.length < msgKeyPackLen) {
             return;
         }
-        const masterDecr = (0, correspondent_keys_1.msgMasterDecryptor)(this.cryptor, recipKey.pair.skey, { kid: '', k: senderPKey });
+        const msgMasterKey = ecma_nacl_1.box.calc_dhshared_key(buffer_utils_1.base64.open(senderPKey), buffer_utils_1.base64.open(recipKey.pair.skey.k));
+        const masterDecr = (0, async_cryptor_wrap_1.makeDecryptor)(cryptor, workLabel, msgMasterKey);
         try {
             const mainObjFileKey = await masterDecr.open(h.subarray(0, msgKeyPackLen));
-            const info = {
+            const decrInfo = {
                 correspondent: undefined,
                 keyStatus: recipKey.role,
                 key: mainObjFileKey,
                 msgKeyPackLen
             };
-            return info;
+            return { decrInfo, introKey: recipKey.pair };
         }
         catch (err) {
             if (!err.failedCipherVerification) {
@@ -162,60 +93,35 @@ class Keyrings {
             masterDecr.destroy();
         }
     }
-    findEstablishedReceptionPairs(pid) {
-        const emails = this.pairIdToEmailMap.getEmails(pid);
-        if (!emails) {
-            return;
-        }
-        const decryptors = [];
-        for (const email of emails) {
-            const ck = this.corrKeys.get(email);
-            if (!ck) {
-                return;
-            }
-            const rp = ck.getReceivingPair(pid);
-            if (!rp) {
-                return;
-            }
-            decryptors.push({
-                correspondent: email,
-                role: rp.role,
-                pair: rp.pair
-            });
-        }
-        return decryptors;
-    }
-    async decryptMsgKeyWithEstablishedPair(pid, getMainObjHeader) {
-        const pairs = this.findEstablishedReceptionPairs(pid);
+    async function decryptMsgKeyWithEstablishedPair(pid, getMainObjHeader) {
+        const pairs = peerKeys.findEstablishedReceptionPairs(pid);
         if (!pairs) {
             return;
         }
         // try to open main object's file key from a header
         const h = await getMainObjHeader();
-        for (const { correspondent, pair, role } of pairs) {
-            const masterKey = buffer_utils_1.base64.open(pair.msgMasterKey);
-            const masterDecr = (0, async_cryptor_wrap_1.makeDecryptor)(this.cryptor, this.workLabel, masterKey);
-            masterKey.fill(0);
+        for (const { msgMasterKey, pairAlg, peerCAddr, ratchetStage, peerKId, recipientKId } of pairs) {
+            const masterDecr = (0, async_cryptor_wrap_1.makeDecryptor)(cryptor, workLabel, msgMasterKey);
+            msgMasterKey.fill(0);
             try {
-                const msgKeyPackLen = msgKeyPackLenForPair(pair);
+                const msgKeyPackLen = (0, common_1.msgKeyPackSizeFor)(pairAlg);
                 if (h.length < msgKeyPackLen) {
                     continue;
                 }
                 const mainObjFileKey = await masterDecr.open(h.subarray(0, msgKeyPackLen));
                 const keyInfo = {
-                    correspondent: correspondent,
-                    keyStatus: role,
+                    correspondent: peerKeys.getPeerAddressForCanonical(peerCAddr) || peerCAddr,
+                    keyStatus: ratchetStage,
                     key: mainObjFileKey,
                     msgKeyPackLen
                 };
                 // set pair as in use
                 if (keyInfo.keyStatus === 'suggested') {
-                    const corrKeys = this.corrKeys.get(keyInfo.correspondent);
-                    corrKeys.markPairAsInUse(pair);
+                    await peerKeys.markPairAsInUse(peerCAddr, peerKId, recipientKId);
                 }
                 return {
                     keyInfo,
-                    incrMsgCount: msgCount => this.updateReceivedMsgCountIn(pair, msgCount)
+                    incrMsgCount: msgCount => peerKeys.updateReceivedMsgCountIn(peerCAddr, peerKId, recipientKId, msgCount, Date.now())
                 };
             }
             catch (err) {
@@ -228,58 +134,13 @@ class Keyrings {
             }
         }
     }
-    /**
-     * This method updates message counts and a timestamp in a given reception
-     * pair.
-     * @param rp is a sending pair, in which changes should be done. Note this
-     * must be a shared structure at this point, not a copy of a pair.
-     * @param msgCount is a message count that should be added to the pair.
-     */
-    updateReceivedMsgCountIn(rp, msgCount) {
-        const lastTS = Date.now();
-        if (!rp.receivedMsgs) {
-            rp.receivedMsgs = { counts: [], lastTS };
-        }
-        (0, common_2.addToNumberLineSegments)(rp.receivedMsgs.counts, msgCount);
-        rp.receivedMsgs.lastTS = lastTS;
-        this.saveChanges();
-    }
-    absorbSuggestedNextKeyPair(correspondent, pair) {
-        let ck = this.corrKeys.get(correspondent);
-        if (!ck) {
-            ck = this.addCorrespondent(correspondent);
-        }
-        if (pair.isSenderIntroKey) {
-            const usedIntro = this.publishedKeys.find(pair.senderKid);
-            if (!usedIntro) {
-                throw new Error(`Recently used published intro key is not found`);
-            }
-            ck.ratchetUpSendingPair(pair, usedIntro.pair);
-        }
-        else {
-            ck.ratchetUpSendingPair(pair);
-        }
-        // if (ck) {
-        // 	ck.ratchetUpSendingPair(pair);
-        // } else {
-        // 	if (!pair.isSenderIntroKey) {
-        // 		throw new Error(`Expected addition of correspondent to be done, when new `);
-        // 	}
-        // 	const usedIntro = this.publishedKeys.find(pair.senderKid);
-        // 	if (!usedIntro) {
-        // 		throw new Error(`Recently used published intro key is not found`);
-        // 	}
-        // 	ck = this.addCorrespondent(correspondent);
-        // 	ck.ratchetUpSendingPair(pair, usedIntro.pair);
-        // }
-        this.saveChanges();
-    }
-    async decrypt(msgMeta, getMainObjHeader, getOpenedMsg, checkMidKeyCerts) {
+    async function decrypt(msgMeta, getMainObjHeader, getOpenedMsg, checkMidKeyCerts) {
         let decrInfo;
+        let introKey = undefined;
         let incrMsgCount;
         let openedMsg;
         if (msgMeta.pid) {
-            const r = await this.decryptMsgKeyWithEstablishedPair(msgMeta.pid, getMainObjHeader);
+            const r = await decryptMsgKeyWithEstablishedPair(msgMeta.pid, getMainObjHeader);
             if (!r) {
                 return;
             }
@@ -288,10 +149,12 @@ class Keyrings {
             openedMsg = await getOpenedMsg(decrInfo.key, decrInfo.msgKeyPackLen);
         }
         else {
-            decrInfo = await this.decryptMsgKeyWithIntroPair(msgMeta.recipientKid, msgMeta.senderPKey, getMainObjHeader);
-            if (!decrInfo) {
+            const r = await decryptMsgKeyWithIntroPair(msgMeta.recipientKid, msgMeta.senderPKey, getMainObjHeader);
+            if (!r) {
                 return;
             }
+            decrInfo = r.decrInfo;
+            introKey = r.introKey;
             openedMsg = await getOpenedMsg(decrInfo.key, decrInfo.msgKeyPackLen);
             const certs = openedMsg.introCryptoCerts;
             const { address, pkey } = await checkMidKeyCerts(certs);
@@ -310,46 +173,50 @@ class Keyrings {
             incrMsgCount(openedMsg.msgCount);
         }
         // absorb next crypto
-        const pair = openedMsg.nextCrypto;
-        if (pair) {
+        const suggestedPair = openedMsg.nextCrypto;
+        if (suggestedPair) {
             try {
-                if (msgMeta.recipientKid) {
-                    if (!pair.isSenderIntroKey) {
-                        throw new Error(`Introductory message is not referencing used intro key in the next crypto`);
-                    }
-                    if (msgMeta.recipientKid !== pair.senderKid) {
+                if (introKey) {
+                    if (introKey.pkey.kid !== suggestedPair.senderKid) {
                         throw new Error(`Introductory message is referencing wrong key in the next crypto`);
                     }
+                    await peerKeys.absorbNextPairSuggestedByPeer(decrInfo.correspondent, suggestedPair, introKey);
+                }
+                else {
+                    await peerKeys.absorbNextPairSuggestedByPeer(decrInfo.correspondent, suggestedPair);
                 }
-                this.absorbSuggestedNextKeyPair(decrInfo.correspondent, pair);
             }
             catch (err) {
-                this.logger.logError(err, `Fail to absorb next suggested key for messaging`);
+                logger.logError(err, `Fail to absorb next suggested key for messaging`);
             }
         }
         return { decrInfo, openedMsg };
     }
     ;
-    async close() {
-        await this.publishedKeys.close();
-        await this.storage.close();
+    async function close() {
+        await publishedKeys.close();
+        await peerKeys.close();
     }
-    makeKeyringsCAP() {
+    function makeKeyringsCAP() {
         const w = {
-            introKeyOnASMailServer: this.publishedKeys.makeIntroKeyCAP(),
-            getCorrespondentKeys: async (addr) => {
-                var _a;
-                const cAddr = (0, canonical_address_1.toCanonicalAddress)(addr);
-                return (_a = this.corrKeys.get(cAddr)) === null || _a === void 0 ? void 0 : _a.toInfo();
-            }
+            introKeyOnASMailServer: publishedKeys.makeIntroKeyCAP(),
+            getCorrespondentKeys: async (peerAddr) => peerKeys.getPeerKeysInfo(peerAddr)
         };
         return Object.freeze(w);
     }
-}
-exports.Keyrings = Keyrings;
-Object.freeze(Keyrings.prototype);
-Object.freeze(Keyrings);
-function msgKeyPackLenForPair(p) {
-    return (0, common_1.msgKeyPackSizeFor)(p.recipientKey.skey.alg);
+    function forASMail() {
+        return {
+            close,
+            decrypt,
+            generateIntroKeysToSendMsg,
+            getEstablishedKeysToSendMsg,
+            needIntroKeyFor: peerKeys.needIntroKeyFor
+        };
+    }
+    return {
+        close,
+        makeKeyringsCAP,
+        forASMail
+    };
 }
 Object.freeze(exports);

package/build/core/keyring/introductory-keys/published-intro-key.d.ts

@@ -0,0 +1,17 @@
+import { ParamOnServer } from '../../../lib-client/asmail/service-config';
+import { AsyncRNG } from '../../../lib-common/rng-def';
+import { GetSigner } from '../../id-manager';
+import { JWKeyPair, MsgKeyRole } from '../common';
+type WritableFile = web3n.files.WritableFile;
+type IntroKeyCAP = web3n.keys.Keyrings['introKeyOnASMailServer'];
+export declare function makeHolderOfPublishedIntroKey(file: WritableFile, getSigner: GetSigner, random: AsyncRNG, pkeyOnServer: ParamOnServer<'init-pub-key'>): Promise<{
+    startExpiryCheckProcess: () => void;
+    close: () => Promise<void>;
+    makeIntroKeyCAP: () => IntroKeyCAP;
+    find: (kid: string) => {
+        role: MsgKeyRole;
+        pair: JWKeyPair;
+        replacedAt?: number;
+    } | undefined;
+}>;
+export {};