core-3nweb-client-lib 0.49.7 → 0.50.0

package/build/api-defs/asmail.d.ts

@@ -299,6 +299,7 @@ declare namespace web3n.asmail {
 		objNotFound?: true;
 		objId?: string;
 		msgIsBroken?: true;
+		failToDecrypt?: true;
 	}
 
 	interface ASMailSendException extends RuntimeException {

package/build/api-defs/files.d.ts

@@ -1172,7 +1172,7 @@ declare namespace web3n.files {
 
 	interface FileChangeEvent extends FSChangeEvent {
 		type: 'file-change';
-		newVersion?: number;
+		newVersion: number;
 	}
 
 	type RemoteEvent = RemoteVersionArchivalEvent | RemoteArchVerRemovalEvent |

package/build/core/asmail/delivery/per-recipient-wip.js

@@ -132,9 +132,13 @@ class WIP {
         const recipient = this.state.recipient;
         const sp = this.msg.r.correspondents.paramsForSendingTo(recipient);
         if (sp) {
+            // DEBUG
+            // console.log(`sending params for sending to ${recipient} invitation are`, sp);
             this.sender = await sender_1.MailSender.fresh(this.msg.r.makeNet(), this.msg.r.asmailResolver, (sp.auth ? senderAddress : undefined), recipient, sp.invitation);
         }
         else {
+            // DEBUG
+            // console.log(`have no sending params to use for sending to ${recipient}`);
             this.sender = await sender_1.MailSender.fresh(this.msg.r.makeNet(), this.msg.r.asmailResolver, undefined, recipient);
         }
         await this.sender.startSession();

package/build/core/asmail/inbox/index.d.ts

@@ -72,35 +72,12 @@ export interface ResourcesForReceiving {
  * messages have not been removed via direct action or due to expiry.
  * This object is also responsible for expiring messages on the server.
  */
-export declare class InboxOnServer {
-    private readonly r;
-    private readonly msgReceiver;
-    private readonly storages;
-    private readonly cryptor;
-    private readonly random;
-    private readonly downloader;
-    private readonly cache;
-    private readonly index;
-    private readonly logError;
-    private readonly inboxEvents;
-    private readonly procs;
-    private readonly recentlyOpenedMsgs;
-    private constructor();
-    static makeAndStart(cachePath: string, syncedFS: WritableFS, localFS: WritableFS, r: ResourcesForReceiving): Promise<InboxOnServer>;
-    close(): Promise<void>;
-    makeCAP(): InboxService;
-    private removeMsg;
-    private removeMsgFromServerAndCache;
-    private msgFromDiskOrDownload;
-    private startCachingAndAddKeyToIndex;
-    private markOwnParams;
-    private absorbSendingParams;
-    private listMsgs;
-    private listNewMsgs;
-    private getMsg;
-    private msgToUIForm;
-    suspendNetworkActivity(): void;
-    resumeNetworkActivity(): void;
-    get connectivityEvent$(): import("rxjs").Observable<import("./inbox-events").InboxConnectionStatus>;
-}
+export type InboxOnServer = Awaited<ReturnType<typeof makeInboxOnServer>>;
+export declare function makeInboxOnServer(cachePath: string, syncedFS: WritableFS, localFS: WritableFS, r: ResourcesForReceiving): Promise<{
+    connectivityEvent$: import("rxjs").Observable<import("./inbox-events").InboxConnectionStatus>;
+    resumeNetworkActivity: () => void;
+    suspendNetworkActivity: () => void;
+    close: () => Promise<void>;
+    makeCAP: () => InboxService;
+}>;
 export {};

package/build/core/asmail/inbox/index.js

@@ -16,8 +16,7 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InboxOnServer = void 0;
-const error_1 = require("../../../lib-common/exceptions/error");
+exports.makeInboxOnServer = makeInboxOnServer;
 const synced_1 = require("../../../lib-common/processes/synced");
 const recipient_1 = require("../../../lib-client/asmail/recipient");
 const opener_1 = require("../msg/opener");
@@ -32,189 +31,165 @@ const cached_msgs_1 = require("./cached-msgs");
 const timed_cache_1 = require("../../../lib-common/timed-cache");
 const fs_sync_utils_1 = require("../../../lib-client/fs-utils/fs-sync-utils");
 const MSG_INDEX_FOLDER = 'msg-index';
-/**
- * Instance of this class represents inbox-on-mail-server.
- * It uses api to manage messages on a ASMail server, caching and recording
- * some information to allow faster response, and to keep message keys, while
- * messages have not been removed via direct action or due to expiry.
- * This object is also responsible for expiring messages on the server.
- */
-class InboxOnServer {
-    constructor(r, msgReceiver, storages, cryptor, random, downloader, cache, index, logError) {
-        this.r = r;
-        this.msgReceiver = msgReceiver;
-        this.storages = storages;
-        this.cryptor = cryptor;
-        this.random = random;
-        this.downloader = downloader;
-        this.cache = cache;
-        this.index = index;
-        this.logError = logError;
-        this.procs = new synced_1.NamedProcs();
-        this.recentlyOpenedMsgs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
-        this.inboxEvents = new inbox_events_1.InboxEvents(this.msgReceiver, this.getMsg.bind(this), this.listNewMsgs.bind(this), this.removeMsg.bind(this), this.logError);
-        Object.seal(this);
+async function makeInboxOnServer(cachePath, syncedFS, localFS, r) {
+    const procs = new synced_1.NamedProcs();
+    const recentlyOpenedMsgs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
+    const { getStorages, cryptor, random, logError, } = r;
+    (0, file_1.ensureCorrectFS)(syncedFS, 'synced', true);
+    const indexSyncedFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, MSG_INDEX_FOLDER);
+    const indexLocalFS = await localFS.writableSubRoot(MSG_INDEX_FOLDER);
+    const msgReceiver = new recipient_1.MailRecipient(r.address, r.getSigner, () => r.asmailResolver(r.address), r.makeNet());
+    const downloader = new msg_downloader_1.MsgDownloader(msgReceiver);
+    const cache = await cached_msgs_1.CachedMessages.makeFor(cachePath, downloader, r.logError);
+    const index = await (0, msg_indexing_1.makeMsgIndex)(indexSyncedFS, indexLocalFS, r.logError);
+    const inboxEvents = new inbox_events_1.InboxEvents(msgReceiver, getMsg, listNewMsgs, removeMsg, r.logError);
+    async function close() {
+        index.stopSyncing();
+        inboxEvents.close();
     }
-    static async makeAndStart(cachePath, syncedFS, localFS, r) {
-        try {
-            (0, file_1.ensureCorrectFS)(syncedFS, 'synced', true);
-            const msgReceiver = new recipient_1.MailRecipient(r.address, r.getSigner, () => r.asmailResolver(r.address), r.makeNet());
-            const downloader = new msg_downloader_1.MsgDownloader(msgReceiver);
-            const cache = await cached_msgs_1.CachedMessages.makeFor(cachePath, downloader, r.logError);
-            const indexSyncedFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, MSG_INDEX_FOLDER);
-            const indexLocalFS = await localFS.writableSubRoot(MSG_INDEX_FOLDER);
-            const index = await (0, msg_indexing_1.makeMsgIndex)(indexSyncedFS, indexLocalFS, r.logError);
-            const inbox = new InboxOnServer(r.correspondents, msgReceiver, r.getStorages, r.cryptor, r.random, downloader, cache, index, r.logError);
-            return inbox;
-        }
-        catch (err) {
-            throw (0, error_1.errWithCause)(err, 'Failed to initialize Inbox');
-        }
-    }
-    async close() {
-        this.index.stopSyncing();
-        this.inboxEvents.close();
-    }
-    makeCAP() {
+    function makeCAP() {
         const service = {
-            getMsg: this.getMsg.bind(this),
-            listMsgs: this.listMsgs.bind(this),
-            removeMsg: this.removeMsg.bind(this),
-            subscribe: this.inboxEvents.subscribe.bind(this.inboxEvents)
+            getMsg,
+            listMsgs,
+            removeMsg,
+            subscribe: inboxEvents.subscribe.bind(inboxEvents)
         };
         return Object.freeze(service);
     }
-    async removeMsg(msgId) {
+    async function removeMsg(msgId) {
         // check for an already started process
         const procId = 'removal of ' + msgId;
-        const promise = this.procs.latestTaskAtThisMoment(procId);
+        const promise = procs.latestTaskAtThisMoment(procId);
         if (promise) {
             return promise;
         }
         // start removal process
-        return this.procs.start(procId, (async () => {
+        return procs.start(procId, (async () => {
             await Promise.all([
-                this.index.remove(msgId),
-                this.removeMsgFromServerAndCache(msgId)
+                index.remove(msgId),
+                removeMsgFromServerAndCache(msgId)
             ]);
         }));
     }
-    async removeMsgFromServerAndCache(msgId) {
+    async function removeMsgFromServerAndCache(msgId) {
         await Promise.all([
-            this.cache.deleteMsg(msgId),
+            cache.deleteMsg(msgId),
             // XXX the following is suspicious, as it swallows other exceptions too
-            this.msgReceiver.removeMsg(msgId).catch(() => { })
+            msgReceiver.removeMsg(msgId).catch(() => { })
         ]);
     }
-    async msgFromDiskOrDownload(msgId) {
-        const msgOnDisk = await this.cache.findMsg(msgId);
+    async function msgFromDiskOrDownload(msgId) {
+        const msgOnDisk = await cache.findMsg(msgId);
         if (msgOnDisk) {
             return msgOnDisk;
         }
-        const meta = await this.downloader.getMsgMeta(msgId);
-        return await this.cache.addMsg(msgId, meta);
+        const meta = await downloader.getMsgMeta(msgId);
+        return await cache.addMsg(msgId, meta);
+    }
+    function checkerOfMidKeyCerts(deliveryTS) {
+        return (certs) => (0, key_verification_1.checkAndExtractPKeyWithAddress)(msgReceiver.getNet(), r.correspondents.midResolver, certs, Math.round(deliveryTS / 1000));
+    }
+    function msgReadingAndOpening(msgId, mainObjId, msgOnDisk) {
+        // lazy main obj source
+        let mainObjSrc = undefined;
+        async function getMainObjHeader() {
+            if (!mainObjSrc) {
+                mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
+            }
+            return mainObjSrc.readHeader();
+        }
+        async function getOpenedMsg(mainObjFileKey, msgKeyPackLen) {
+            if (!mainObjSrc) {
+                mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
+            }
+            return await (0, opener_1.openMsg)(msgId, mainObjId, mainObjSrc, msgKeyPackLen, mainObjFileKey, cryptor);
+        }
+        return {
+            getMainObjHeader, getOpenedMsg
+        };
     }
-    async startCachingAndAddKeyToIndex(msgId) {
-        const msgOnDisk = await this.msgFromDiskOrDownload(msgId);
+    async function startCachingAndAddKeyToIndex(msgId) {
+        const msgOnDisk = await msgFromDiskOrDownload(msgId);
         const meta = await msgOnDisk.getMsgMeta();
+        const { getMainObjHeader, getOpenedMsg } = msgReadingAndOpening(msgId, meta.extMeta.objIds[0], msgOnDisk);
         try {
-            // setup closures, some memoized, for use by keyring
-            let mainObjSrc = undefined;
-            const mainObjId = meta.extMeta.objIds[0];
-            const getMainObjHeader = async () => {
-                if (!mainObjSrc) {
-                    mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
-                }
-                return mainObjSrc.readHeader();
-            };
-            const getOpenedMsg = async (mainObjFileKey, msgKeyPackLen) => {
-                if (!mainObjSrc) {
-                    mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
-                }
-                const openedMsg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObjSrc, msgKeyPackLen, mainObjFileKey, this.cryptor);
-                return openedMsg;
-            };
-            const checkMidKeyCerts = (certs) => {
-                return (0, key_verification_1.checkAndExtractPKeyWithAddress)(this.msgReceiver.getNet(), this.r.midResolver, certs, Math.round(msgOnDisk.deliveryTS / 1000));
-            };
-            const decrOut = await this.r.msgDecryptor(meta.extMeta, getMainObjHeader, getOpenedMsg, checkMidKeyCerts);
+            const decrOut = await r.correspondents.msgDecryptor(meta.extMeta, getMainObjHeader, getOpenedMsg, checkerOfMidKeyCerts(msgOnDisk.deliveryTS));
             if (decrOut) {
                 const { decrInfo, openedMsg } = decrOut;
                 openedMsg.setMsgKeyRole(decrInfo.keyStatus);
+                // XXX we have never used this part of protocol, should it be removed at all from ASMail protocol?
                 checkServerAuthIfPresent(meta, decrInfo);
                 // add records cache and to index
-                this.recentlyOpenedMsgs.set(msgId, openedMsg);
+                recentlyOpenedMsgs.set(msgId, openedMsg);
                 const msgInfo = {
                     msgType: openedMsg.getSection('Msg Type'),
                     msgId,
                     deliveryTS: msgOnDisk.deliveryTS
                 };
-                await this.index.add(msgInfo, decrInfo);
+                await index.add(msgInfo, decrInfo);
                 await Promise.all([
-                    this.absorbSendingParams(openedMsg),
-                    this.markOwnParams(meta, openedMsg.sender)
+                    absorbSendingParams(openedMsg),
+                    markOwnParams(meta, openedMsg.sender)
                 ]);
             }
             else {
                 // check, if msg has already been indexed
-                const knownDecr = await this.index.getKeyFor(msgId, msgOnDisk.deliveryTS);
+                const knownDecr = await index.getKeyFor(msgId, msgOnDisk.deliveryTS);
                 if (!knownDecr) {
-                    await msgOnDisk.updateMsgKeyStatus('not-found');
                     return false;
                 }
-                // TODO try to open main message, just as a check
             }
-            await msgOnDisk.updateMsgKeyStatus('ok');
             return true;
         }
         catch (exc) {
-            await this.logError(exc, `Problem with opening message ${msgId}`);
-            if (msgOnDisk.keyStatus !== 'ok') {
-                await msgOnDisk.updateMsgKeyStatus('fail');
-            }
+            await logError(exc, `Problem with opening message ${msgId}`);
             return false;
         }
     }
-    async markOwnParams(meta, sender) {
+    async function markOwnParams(meta, sender) {
+        // DEBUG
+        // console.log(`  markOwnParams (if invite used) ->`, {sender, 'meta.invite':meta.invite});
         if (!meta.invite) {
             return;
         }
-        await this.r.markOwnSendingParamsAsUsed(sender, meta.invite);
+        await r.correspondents.markOwnSendingParamsAsUsed(sender, meta.invite);
     }
-    async absorbSendingParams(openedMsg) {
+    async function absorbSendingParams(openedMsg) {
         const sendingParams = openedMsg.nextSendingParams;
+        // DEBUG
+        // console.log(`  openedMsg.nextSendingParams ->`, openedMsg.nextSendingParams);
         if (!sendingParams) {
             return;
         }
         const address = openedMsg.sender;
-        await this.r.saveParamsForSendingTo(address, sendingParams);
+        await r.correspondents.saveParamsForSendingTo(address, sendingParams);
     }
-    async listMsgs(fromTS) {
-        const checkServer = true; // XXX in future this will be an option from req
-        if (!checkServer) {
-            return this.index.listMsgs(fromTS);
-        }
-        // check for an already started process
-        const procId = 'listing msgs';
-        const promise = this.procs.latestTaskAtThisMoment(procId);
+    function debouncingProc(procId, action) {
+        const promise = procs.latestTaskAtThisMoment(procId);
         if (promise) {
             return promise;
         }
-        // start message listing process
-        return this.procs.start(procId, async () => {
+        return procs.start(procId, action);
+    }
+    async function listMsgs(fromTS) {
+        const checkServer = true; // XXX in future this will be an option from req
+        if (!checkServer) {
+            return index.listMsgs(fromTS);
+        }
+        return debouncingProc('listing msgs', async () => {
             // message listing info is located in index, yet, process involves
             // getting and caching messages' metadata
             let msgIds;
             try {
-                msgIds = await this.msgReceiver.listMsgs(fromTS);
+                msgIds = await msgReceiver.listMsgs(fromTS);
             }
             catch (exc) {
                 if (exc.type !== 'connect') {
                     throw exc;
                 }
-                return this.index.listMsgs(fromTS);
+                return index.listMsgs(fromTS);
             }
-            const indexedMsgs = await this.index.listMsgs(fromTS);
+            const indexedMsgs = await index.listMsgs(fromTS);
             for (const info of indexedMsgs) {
                 const ind = msgIds.indexOf(info.msgId);
                 if (ind >= 0) {
@@ -224,17 +199,17 @@ class InboxOnServer {
             if (msgIds.length === 0) {
                 return indexedMsgs;
             }
-            await Promise.all(msgIds.map(msgId => this.startCachingAndAddKeyToIndex(msgId)
+            await Promise.all(msgIds.map(msgId => startCachingAndAddKeyToIndex(msgId)
                 .catch(async (exc) => {
-                await this.logError(exc, `Failed to start caching message ${msgId}`);
+                await logError(exc, `Failed to start caching message ${msgId}`);
             })));
-            return this.index.listMsgs(fromTS);
+            return index.listMsgs(fromTS);
         });
     }
-    async listNewMsgs(fromTS) {
-        const msgIds = await this.msgReceiver.listMsgs(fromTS);
+    async function listNewMsgs(fromTS) {
+        const msgIds = await msgReceiver.listMsgs(fromTS);
         // remove from listing messages already in index
-        const indexedMsgs = await this.index.listMsgs(fromTS);
+        const indexedMsgs = await index.listMsgs(fromTS);
         for (const info of indexedMsgs) {
             const ind = msgIds.indexOf(info.msgId);
             if (ind >= 0) {
@@ -245,54 +220,39 @@ class InboxOnServer {
             return [];
         }
         // cache and index these
-        await Promise.all(msgIds.map(msgId => this.startCachingAndAddKeyToIndex(msgId)));
+        await Promise.all(msgIds.map(msgId => startCachingAndAddKeyToIndex(msgId)));
         // get info's from index, focusing on specific messages only
-        return (await this.index.listMsgs(fromTS)).filter(({ msgId }) => msgIds.includes(msgId));
+        return (await index.listMsgs(fromTS)).filter(({ msgId }) => msgIds.includes(msgId));
     }
-    async getMsg(msgId) {
+    async function getMsg(msgId) {
         if (!msgId || (typeof msgId !== 'string')) {
             throw `Given message id is not a non-empty string`;
         }
-        const procId = `get msg #${msgId}`;
-        const promise = this.procs.latestTaskAtThisMoment(procId);
-        if (promise) {
-            return promise;
-        }
-        return this.procs.start(procId, async () => {
-            const msgOnDisk = await this.msgFromDiskOrDownload(msgId);
-            let msg = this.recentlyOpenedMsgs.get(msgId);
+        return debouncingProc(`get msg #${msgId}`, async () => {
+            const msgOnDisk = await msgFromDiskOrDownload(msgId);
+            let msg = recentlyOpenedMsgs.get(msgId);
             if (msg) {
-                return this.msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
-            }
-            if ((msgOnDisk.keyStatus === 'not-found')
-                || (msgOnDisk.keyStatus === 'fail')) {
-                // XXX 
-                // message cannot be opened, and should be removed
-                // await Promise.all([
-                // 	this.index.remove(msgInfo),
-                // 	this.removeMsgFromServerAndCache(msgId)
-                // ]);
-                throw (0, recipient_1.makeMsgNotFoundException)(msgId);
-            }
-            else if (msgOnDisk.keyStatus === 'not-checked') {
-                await this.startCachingAndAddKeyToIndex(msgId);
-            }
-            else if (msgOnDisk.keyStatus !== 'ok') {
-                throw new Error(`Unknown message key status ${msgOnDisk.keyStatus}`);
+                return msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
             }
             const meta = await msgOnDisk.getMsgMeta();
             const mainObjId = meta.extMeta.objIds[0];
             const mainObj = await msgOnDisk.getMsgObj(mainObjId);
-            const msgKey = await this.index.getKeyFor(msgId, meta.deliveryCompletion);
+            let msgKey = await index.getKeyFor(msgId, meta.deliveryCompletion);
             if (!msgKey) {
-                throw (0, recipient_1.makeMsgNotFoundException)(msgId);
+                if (!(await startCachingAndAddKeyToIndex(msgId))) {
+                    throw (0, recipient_1.makeFailToDecryptMsgException)(msgId);
+                }
+                msgKey = await index.getKeyFor(msgId, meta.deliveryCompletion);
+                if (!msgKey) {
+                    throw (0, recipient_1.makeFailToDecryptMsgException)(msgId);
+                }
             }
-            msg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObj, msgKey.mainObjHeaderOfs, msgKey.msgKey, this.cryptor);
+            msg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObj, msgKey.mainObjHeaderOfs, msgKey.msgKey, cryptor);
             msg.setMsgKeyRole(msgKey.msgKeyRole);
-            return this.msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
+            return msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
         });
     }
-    msgToUIForm(msg, deliveryTS, msgOnDisk) {
+    function msgToUIForm(msg, deliveryTS, msgOnDisk) {
         const m = {
             sender: msg.sender,
             establishedSenderKeyChain: msg.establishedKeyChain,
@@ -317,23 +277,18 @@ class InboxOnServer {
         }
         const attachments = msg.attachmentsJSON;
         if (attachments) {
-            m.attachments = (0, fs_1.fsForAttachments)(msgOnDisk, attachments, this.storages, this.cryptor, this.random, this.logError);
+            m.attachments = (0, fs_1.fsForAttachments)(msgOnDisk, attachments, getStorages, cryptor, random, logError);
         }
         return m;
     }
-    suspendNetworkActivity() {
-        this.inboxEvents.suspendNetworkActivity();
-    }
-    resumeNetworkActivity() {
-        this.inboxEvents.resumeNetworkActivity();
-    }
-    get connectivityEvent$() {
-        return this.inboxEvents.connectionEvent$;
-    }
+    return {
+        connectivityEvent$: inboxEvents.connectionEvent$,
+        resumeNetworkActivity: inboxEvents.resumeNetworkActivity.bind(inboxEvents),
+        suspendNetworkActivity: inboxEvents.suspendNetworkActivity.bind(inboxEvents),
+        close,
+        makeCAP
+    };
 }
-exports.InboxOnServer = InboxOnServer;
-Object.freeze(InboxOnServer.prototype);
-Object.freeze(InboxOnServer);
 function checkServerAuthIfPresent(meta, { correspondent }) {
     // if sender authenticated to server, check that it matches address,
     // recovered from message decryption 

package/build/core/asmail/inbox/msg-indexing/index.js

@@ -27,9 +27,9 @@ const INDEX_DIR = 'index';
 const NUM_OF_ENTRIES_TO_CHOP_DB = 200;
 async function makeMsgIndex(syncedFS, localFS, logError) {
     // file systems within dataset
-    const logsFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, LOGS_DIR);
+    const logsFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, LOGS_DIR);
     const localLogsFS = await localFS.writableSubRoot(LOGS_DIR);
-    const indexFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, INDEX_DIR);
+    const indexFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, INDEX_DIR);
     const logs = await (0, logs_1.makeRecentMsgIndexChangesLogs)(logsFS, localLogsFS, logError);
     const indexed = await (0, sql_db_1.makeSqliteDBs)(indexFS);
     async function add(msgInfo, decrInfo) {
@@ -45,13 +45,12 @@ async function makeMsgIndex(syncedFS, localFS, logError) {
         }
     }
     async function periodicCheckAndUploadOfData() {
-        // XXX disable uploading for a moment by commenting out
-        // const shardTS = Date.now() - 10*60*1000;
-        // const countBefore = indexed.numberOfRecordsInLatestBefore(shardTS);
-        // if (countBefore >= NUM_OF_ENTRIES_TO_CHOP_DB) {
-        // 	const syncedIndexDbVersion = await indexed.makeNewShardWithRecordsUpToTS(shardTS);
-        // 	await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion, { shardTS });
-        // }
+        const shardTS = Date.now() - 10 * 60 * 1000;
+        const countBefore = indexed.numberOfRecordsInLatestBefore(shardTS);
+        if (countBefore >= NUM_OF_ENTRIES_TO_CHOP_DB) {
+            const syncedIndexDbVersion = await indexed.makeNewShardWithRecordsUpToTS(shardTS);
+            await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion, { shardTS });
+        }
     }
     function millisBeforeNextRun() {
         return 30 * 60 * 1000 + Math.floor(10 * 60 * 1000 * Math.random());

package/build/core/asmail/inbox/msg-on-disk.d.ts

@@ -2,14 +2,12 @@ import { ObjOnDisk } from '../../../lib-client/objs-on-disk/obj-on-disk';
 import { MsgMeta } from '../../../lib-common/service-api/asmail/retrieval';
 import { ObjSource } from 'xsp-files';
 import { MsgDownloader } from './msg-downloader';
-export type MsgKeyStatus = 'not-checked' | 'not-found' | 'fail' | 'ok';
 export interface ObjSize {
     header: number;
     segments: number;
 }
 export interface MsgStatus {
     msgId: string;
-    keyStatus: MsgKeyStatus;
     onDisk: boolean;
     mainObjId: string;
     deliveryTS: number;
@@ -31,7 +29,4 @@ export declare class MsgOnDisk {
     getObjFile(objId: string): Promise<ObjOnDisk>;
     getMsgObj(objId: string): Promise<ObjSource>;
     get deliveryTS(): number;
-    get keyStatus(): MsgKeyStatus;
-    updateMsgKeyStatus(newStatus: Exclude<MsgKeyStatus, 'not-checked'>): Promise<void>;
-    private saveStatusToDisk;
 }

package/build/core/asmail/inbox/msg-on-disk.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2019 3NSoft Inc.
+ Copyright (C) 2016 - 2019, 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
@@ -27,7 +27,6 @@ const STATUS_FNAME = 'status.json';
 function makeInitMsgStatus(msgId, meta) {
     return {
         msgId,
-        keyStatus: 'not-checked',
         onDisk: false,
         mainObjId: meta.extMeta.objIds[0],
         deliveryTS: meta.deliveryStart
@@ -94,26 +93,6 @@ class MsgOnDisk {
     get deliveryTS() {
         return this.status.deliveryTS;
     }
-    get keyStatus() {
-        return this.status.keyStatus;
-    }
-    updateMsgKeyStatus(newStatus) {
-        return this.syncProc.startOrChain(async () => {
-            if (this.status.keyStatus === 'not-checked') {
-                this.status.keyStatus = newStatus;
-            }
-            else if (this.status.keyStatus === newStatus) {
-                return;
-            }
-            else {
-                throw Error(`Message has key status ${this.status.keyStatus}, and can't be updated to ${newStatus}`);
-            }
-            await this.saveStatusToDisk();
-        });
-    }
-    async saveStatusToDisk() {
-        await writeJSON(this.msgFolderPath, STATUS_FNAME, this.status);
-    }
 }
 exports.MsgOnDisk = MsgOnDisk;
 Object.freeze(MsgOnDisk.prototype);

package/build/core/asmail/index.js

@@ -61,8 +61,8 @@ class ASMail {
         }
     }
     async setupSendingParams(syncedFS) {
-        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);
+        const fs = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, SEND_PARAMS_DATA_FOLDER);
+        this.sendingParams = await (0, sending_params_1.makeSendingParamsHolder)(fs, this.config.makeParamSetterAndGetter('anon-sender/invites'), this.random);
     }
     async setupDelivery(localFS, getSigner, makeResolver) {
         const fs = await localFS.writableSubRoot(DELIVERY_DATA_FOLDER);
@@ -88,9 +88,9 @@ class ASMail {
     }
     async setupInbox(syncedFS, localFS, getSigner, getStorages, makeResolver) {
         const cachePath = this.inboxPathForUser(this.address);
-        const inboxSyncedFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, INBOX_DATA_FOLDER);
+        const inboxSyncedFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, INBOX_DATA_FOLDER);
         const inboxLocalFS = await localFS.writableSubRoot(INBOX_DATA_FOLDER);
-        this.inbox = await inbox_1.InboxOnServer.makeAndStart(cachePath, inboxSyncedFS, inboxLocalFS, {
+        this.inbox = await (0, inbox_1.makeInboxOnServer)(cachePath, inboxSyncedFS, inboxLocalFS, {
             address: this.address,
             cryptor: this.cryptor,
             random: this.random,

package/build/core/asmail/sending-params/index.d.ts

@@ -6,18 +6,17 @@ export { SendingParams } from './params-from-others';
 type WritableFS = web3n.files.WritableFS;
 type SendingResources = ResourcesForSending['correspondents'];
 type ReceptionResources = ResourcesForReceiving['correspondents'];
-export declare class SendingParamsHolder {
-    private readonly paramsFromOthers;
-    private readonly ownParams;
-    readonly thisSide: {
-        getUpdated: SendingResources['newParamsForSendingReplies'];
-        setAsUsed: ReceptionResources['markOwnSendingParamsAsUsed'];
-    };
-    readonly otherSides: {
-        get: SendingResources['paramsForSendingTo'];
-        set: ReceptionResources['saveParamsForSendingTo'];
-    };
-    private constructor();
-    static makeAndInit(fs: WritableFS, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<SendingParamsHolder>;
-    close(): Promise<void>;
+export interface SendingParamsThisSide {
+    getUpdated: SendingResources['newParamsForSendingReplies'];
+    setAsUsed: ReceptionResources['markOwnSendingParamsAsUsed'];
 }
+export interface SendingParamsOtherSides {
+    get: SendingResources['paramsForSendingTo'];
+    set: ReceptionResources['saveParamsForSendingTo'];
+}
+export interface SendingParamsHolder {
+    thisSide: SendingParamsThisSide;
+    otherSides: SendingParamsOtherSides;
+    close: () => Promise<void>;
+}
+export declare function makeSendingParamsHolder(fs: WritableFS, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<SendingParamsHolder>;