core-3nweb-client-lib 0.49.7 → 0.50.0

package/build/core/asmail/sending-params/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017 - 2018, 2025 3NSoft Inc.
+ Copyright (C) 2017 - 2018, 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,46 +16,26 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SendingParamsHolder = void 0;
+exports.makeSendingParamsHolder = makeSendingParamsHolder;
 const params_from_others_1 = require("./params-from-others");
 const own_params_1 = require("./own-params");
 const invitations_anon_1 = require("./invitations-anon");
 const PARAMS_FROM_OTHERS_FILE = 'params-from-others.json';
 const OWN_PARAMS_FILE = 'own-params.json';
 const ANONYM_INVITES_FILE = 'anonymous-invites.json';
-class SendingParamsHolder {
-    constructor(paramsFromOthers, ownParams) {
-        this.paramsFromOthers = paramsFromOthers;
-        this.ownParams = ownParams;
-        this.otherSides = {
-            get: this.paramsFromOthers.getFor,
-            set: this.paramsFromOthers.setFor
-        };
-        this.thisSide = {
-            getUpdated: this.ownParams.getFor,
-            setAsUsed: this.ownParams.setAsInUse
-        };
-        Object.freeze(this);
-    }
-    static async makeAndInit(fs, anonInvitesOnServer, random) {
-        const [paramsFromOthers, ownParams] = await Promise.all([
-            fs.writableFile(PARAMS_FROM_OTHERS_FILE)
-                .then(f => params_from_others_1.ParamsFromOthers.makeAndInit(f)),
-            fs.writableFile(ANONYM_INVITES_FILE)
-                .then(async (anonInvitesFile) => {
-                const anonInvites = await invitations_anon_1.AnonymousInvites.makeAndInit(anonInvitesFile, anonInvitesOnServer, random);
-                return await own_params_1.OwnSendingParams.makeAndInit(await fs.writableFile(OWN_PARAMS_FILE), anonInvites);
-            })
-        ]);
-        await fs.close();
-        return new SendingParamsHolder(paramsFromOthers, ownParams);
-    }
-    async close() {
-        await this.ownParams.close();
-        await this.paramsFromOthers.close();
+async function makeSendingParamsHolder(fs, anonInvitesOnServer, random) {
+    const [otherSides, thisSide] = await Promise.all([
+        (0, params_from_others_1.makeParamsFromOthers)(fs, PARAMS_FROM_OTHERS_FILE),
+        (0, own_params_1.makeOwnSendingParams)(fs, OWN_PARAMS_FILE, await (0, invitations_anon_1.makeAnonymousInvites)(fs, ANONYM_INVITES_FILE, anonInvitesOnServer, random))
+    ]);
+    async function close() {
+        await thisSide.close();
+        await otherSides.close();
     }
+    return {
+        thisSide,
+        otherSides,
+        close
+    };
 }
-exports.SendingParamsHolder = SendingParamsHolder;
-Object.freeze(SendingParamsHolder.prototype);
-Object.freeze(SendingParamsHolder);
 Object.freeze(exports);

package/build/core/asmail/sending-params/invitations-anon.d.ts

@@ -1,37 +1,13 @@
 import { ParamOnServer } from '../../../lib-client/asmail/service-config';
 import { AsyncRNG } from '../../../lib-common/rng-def';
-type WritableFile = web3n.files.WritableFile;
-interface InvitesJSON {
-    invites: {
-        [invite: string]: {
-            label: string;
-            msgMaxSize: number;
-        };
-    };
-}
-export declare class AnonymousInvites {
-    private readonly anonInvitesOnServer;
-    private readonly random;
-    private invites;
-    private readonly fileProc;
-    private constructor();
-    static makeAndInit(file: WritableFile, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<AnonymousInvites>;
-    private onFileEvent;
-    protected setFromJSON(json: InvitesJSON): void;
-    private toFileJSON;
-    private persist;
-    private absorbRemoteChanges;
-    private toServerParam;
-    private toServiceJSON;
-    private syncServiceSetting;
-    getAll(): Map<string, {
+type WritableFS = web3n.files.WritableFS;
+export type AnonymousInvites = Awaited<ReturnType<typeof makeAnonymousInvites>>;
+export declare function makeAnonymousInvites(fs: WritableFS, fileName: string, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<{
+    create: (label: string, msgMaxSize: number) => Promise<string>;
+    getAll: () => Map<string, {
         invite: string;
         msgMaxSize: number;
     }>;
-    create(label: string, msgMaxSize: number): Promise<string>;
-    private generateNewRandomInvite;
-    private findByLabel;
-    setMsgMaxSize(label: string, msgMaxSize: number): Promise<void>;
-    close(): Promise<void>;
-}
+    close: () => Promise<void>;
+}>;
 export {};

package/build/core/asmail/sending-params/invitations-anon.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 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,160 +16,110 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnonymousInvites = void 0;
-const file_based_json_1 = require("../../../lib-client/xsp-fs/util/file-based-json");
-const json_utils_1 = require("../../../lib-common/json-utils");
+exports.makeAnonymousInvites = makeAnonymousInvites;
 const rng_def_1 = require("../../../lib-common/rng-def");
+const single_file_1 = require("../../../lib-common/dataset-sync/single-file");
 const INVITE_TOKEN_LEN = 40;
-class AnonymousInvites {
-    constructor(anonInvitesOnServer, random) {
-        this.anonInvitesOnServer = anonInvitesOnServer;
-        this.random = random;
-        this.invites = {};
-        this.fileProc = new file_based_json_1.JsonFileProc(this.onFileEvent.bind(this));
-        Object.seal(this);
-    }
-    static async makeAndInit(file, anonInvitesOnServer, random) {
-        const anonInvites = new AnonymousInvites(anonInvitesOnServer, random);
-        await anonInvites.fileProc.start(file, () => anonInvites.toFileJSON());
-        // XXX these are part of proper syncing logic
-        // await anonInvites.absorbRemoteChanges();
-        // await anonInvites.syncServiceSetting();
-        return anonInvites;
-    }
-    async onFileEvent(ev) {
-        if (ev.src === 'local') {
-            return;
+async function makeAnonymousInvites(fs, fileName, anonInvitesOnServer, random) {
+    const { file: invitesFile, changeProc } = await (0, single_file_1.initSyncedFile)(fs, fileName, newFile => newFile.writeJSON({ invites: {} }));
+    function parseInvitesFromJSON(json) {
+        const invites = json.invites;
+        if (invites || (typeof invites === 'object')) {
+            return invites;
         }
-        switch (ev.type) {
-            case 'file-change':
-                await this.fileProc.order.startOrChain(() => this.absorbRemoteChanges());
-                break;
-            case 'removed':
-                throw new Error(`Unexpected removal of file with parameter "anon-sender/invites"`);
-            default:
-                return;
+        else {
+            return {};
         }
     }
-    setFromJSON(json) {
-        this.invites = json.invites;
-    }
-    toFileJSON() {
-        return {
-            invites: this.invites
-        };
+    let invites = parseInvitesFromJSON(await invitesFile.readJSON());
+    async function onChangeFromOtherDevices(newVersion) {
+        changeProc.startOrChain(async () => {
+            const { version, json } = await invitesFile.v.readJSON();
+            if (version === newVersion) {
+                invites = parseInvitesFromJSON(json);
+            }
+        });
     }
-    async persist() {
-        await this.fileProc.order.startOrChain(async () => {
-            await this.anonInvitesOnServer.setOnServer(this.toServerParam());
-            await this.fileProc.save(this.toFileJSON(), false);
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            const { remote, state } = await invitesFile.v.sync.status(false);
+            if ((state !== 'conflicting') || !(remote === null || remote === void 0 ? void 0 : remote.latest)) {
+                return;
+            }
+            const onRemote = (await invitesFile.v.readJSON({ remoteVersion: remote.latest })).json;
+            const numOfInvitesOnRemote = Object.keys(onRemote.invites).length;
+            const numOfCurrentInvites = Object.keys(invites).length;
+            const joined = { ...onRemote.invites, ...invites };
+            const numOfJoined = Object.keys(joined).length;
+            if ((numOfCurrentInvites === numOfInvitesOnRemote) && (numOfCurrentInvites === numOfJoined)) {
+                await invitesFile.v.sync.adoptRemote({ remoteVersion: remote.latest });
+            }
+            else {
+                invites = joined;
+                await invitesFile.writeJSON({ invites });
+                await invitesFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+                await anonInvitesOnServer.setOnServer(invitesToServerParamForm(invites));
+            }
         });
     }
-    async absorbRemoteChanges() {
-        // XXX
-        //  - check for changes: what is needed here from fileProc, and what is
-        //    generic in absorbing remote changes to refactor it into JsonFileProc
-        //  - absorb and sync, if needed: what can be in JsonFileProc
-        // Code from pre-v.sync:
-        // const { json } = await this.fileProc.get();
-        // this.setFromJSON(json);
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(invitesFile, changeProc, onChangeFromOtherDevices, doOnConflict);
+    async function persist() {
+        await anonInvitesOnServer.setOnServer(invitesToServerParamForm(invites));
+        await invitesFile.writeJSON({ invites });
+        triggerUpload();
     }
-    toServerParam() {
+    function invitesToServerParamForm(invites) {
         const serverParam = {};
-        for (const [invite, { msgMaxSize }] of Object.entries(this.invites)) {
+        for (const [invite, { msgMaxSize }] of Object.entries(invites)) {
             serverParam[invite] = msgMaxSize;
         }
         return serverParam;
     }
-    toServiceJSON() {
-        const serverJSON = {};
-        Object.entries(this.invites)
-            .forEach(([invite, params]) => {
-            serverJSON[invite] = params.msgMaxSize;
-        });
-        return serverJSON;
-    }
-    async syncServiceSetting(rethrowConnectExc = false) {
-        // XXX we may have the following bug here:
-        // Device with older version of param gets to this point, and sets older
-        // value.
-        // To protect aginst this case, absorbing from file must ensure highest
-        // synced version is read.
-        try {
-            const infoOnServer = await this.anonInvitesOnServer.getFromServer()
-                .catch((exc) => {
-                if (exc.type === 'connect') {
-                    return;
-                }
-                else {
-                    throw exc;
-                }
-            });
-            const currentVal = this.toServiceJSON();
-            if (!(0, json_utils_1.deepEqual)(infoOnServer, currentVal)) {
-                await this.anonInvitesOnServer.setOnServer(currentVal);
-            }
-        }
-        catch (exc) {
-            if (!rethrowConnectExc
-                && (exc.type === 'connect')) {
-                return;
-            }
-            throw exc;
-        }
-    }
-    getAll() {
+    function getAll() {
         const byLabel = new Map();
-        Object.entries(this.invites)
+        Object.entries(invites)
             .forEach(([invite, params]) => {
             byLabel.set(params.label, { invite, msgMaxSize: params.msgMaxSize });
         });
         return byLabel;
     }
-    ;
-    async create(label, msgMaxSize) {
-        const existingInvite = this.findByLabel(label);
-        if (existingInvite) {
-            throw new Error(`Anonymous sender invite already exists with label ${label}`);
-        }
-        const invite = await this.generateNewRandomInvite();
-        this.invites[invite] = { label, msgMaxSize };
-        try {
-            await this.persist();
-            return invite;
-        }
-        catch (exc) {
-            delete this.invites[invite];
-            throw exc;
-        }
+    function create(label, msgMaxSize) {
+        return changeProc.startOrChain(async () => {
+            const existingInvite = findByLabel(label);
+            if (existingInvite) {
+                throw new Error(`Anonymous sender invite already exists with label ${label}`);
+            }
+            const invite = await generateNewRandomInvite();
+            invites[invite] = { label, msgMaxSize };
+            try {
+                await persist();
+                return invite;
+            }
+            catch (exc) {
+                delete invites[invite];
+                throw exc;
+            }
+        });
     }
-    ;
-    async generateNewRandomInvite() {
+    async function generateNewRandomInvite() {
         let invite;
         do {
-            invite = await (0, rng_def_1.stringOfB64Chars)(INVITE_TOKEN_LEN, this.random);
-        } while (this.invites[invite]);
+            invite = await (0, rng_def_1.stringOfB64Chars)(INVITE_TOKEN_LEN, random);
+        } while (invites[invite]);
         return invite;
     }
-    findByLabel(label) {
-        const found = Object.entries(this.invites)
+    function findByLabel(label) {
+        const found = Object.entries(invites)
             .find(([_, params]) => (params.label === label));
         return (found ? found[0] : undefined);
     }
-    async setMsgMaxSize(label, msgMaxSize) {
-        const invite = this.findByLabel(label);
-        if (!invite) {
-            throw new Error(`There is no anonymous sender invite with label ${label}`);
-        }
-        this.invites[invite].msgMaxSize = msgMaxSize;
-        await this.persist();
-    }
-    ;
-    async close() {
-        await this.fileProc.close();
+    async function close() {
+        stopFileWatching();
     }
+    return {
+        create,
+        getAll,
+        close
+    };
 }
-exports.AnonymousInvites = AnonymousInvites;
-Object.freeze(AnonymousInvites.prototype);
-Object.freeze(AnonymousInvites);
 Object.freeze(exports);

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

@@ -1,28 +1,8 @@
 import { SendingParamsHolder } from './index';
 import { AnonymousInvites } from './invitations-anon';
-type ExposedFuncs = SendingParamsHolder['thisSide'];
-type WritableFile = web3n.files.WritableFile;
-type FileEvent = web3n.files.FileEvent;
-/**
- * Instance of this class keeps track of sending parameters, which user gives to
- * other correspondents for sending messages back. These parameters may have
- * invitation tokens, and this class uses config service to register tokens on
- * a server.
- */
-export declare class OwnSendingParams {
-    private readonly anonInvites;
-    private readonly params;
-    private defaultParams;
-    private readonly fileProc;
-    private constructor();
-    static makeAndInit(file: WritableFile, anonInvites: AnonymousInvites): Promise<OwnSendingParams>;
-    private setDefaultParams;
-    private toFileJSON;
-    private persist;
-    private absorbChangesFromFile;
-    protected onFileEvent(ev: FileEvent): Promise<void>;
-    getFor: ExposedFuncs['getUpdated'];
-    setAsInUse: ExposedFuncs['setAsUsed'];
-    close(): Promise<void>;
-}
+type WritableFS = web3n.files.WritableFS;
+export type OwnSendingParams = Awaited<ReturnType<typeof makeOwnSendingParams>>;
+export declare function makeOwnSendingParams(fs: WritableFS, fileName: string, anonInvites: AnonymousInvites): Promise<SendingParamsHolder['thisSide'] & {
+    close: () => Promise<void>;
+}>;
 export {};

package/build/core/asmail/sending-params/own-params.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017 - 2018, 2025 3NSoft Inc.
+ Copyright (C) 2017 - 2018, 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,126 +16,173 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OwnSendingParams = void 0;
-const file_based_json_1 = require("../../../lib-client/xsp-fs/util/file-based-json");
+exports.makeOwnSendingParams = makeOwnSendingParams;
 const json_utils_1 = require("../../../lib-common/json-utils");
+const single_file_1 = require("../../../lib-common/dataset-sync/single-file");
 const DEFAULT_INVITE_LABEL = 'Default';
 const DEFAULT_INVITE_MAX_MSG_SIZE = 1024 * 1024 * 1024;
-/**
- * Instance of this class keeps track of sending parameters, which user gives to
- * other correspondents for sending messages back. These parameters may have
- * invitation tokens, and this class uses config service to register tokens on
- * a server.
- */
-class OwnSendingParams {
-    constructor(anonInvites) {
-        this.anonInvites = anonInvites;
-        this.params = new Map();
-        this.defaultParams = undefined;
-        this.getFor = async (address) => {
-            let p = this.params.get(address);
-            if (p) {
-                if (p.suggested) {
-                    return p.suggested;
-                }
-                else if (p.inUse) {
-                    return; // undefined, cause params are known to correspondent,
-                    // and there are no params to suggest for future use.
-                }
-            }
-            // XXX Or, instead, should we set defaultParams?
-            if (!this.defaultParams) {
-                return;
-            }
-            p = {
-                address,
-                suggested: (0, json_utils_1.copy)(this.defaultParams)
-            };
-            p.suggested.timestamp = Date.now();
-            this.params.set(p.address, p);
-            await this.fileProc.order.startOrChain(() => this.persist());
-            return p.suggested;
-        };
-        this.setAsInUse = async (address, invite) => {
-            await this.fileProc.order.startOrChain(async () => {
-                const p = this.params.get(address);
-                if (!p || !p.suggested) {
-                    return;
-                }
-                if (p.suggested.invitation !== invite) {
-                    return;
-                }
-                p.inUse = p.suggested;
-                p.suggested = undefined;
-                await this.persist();
-            });
-        };
-        this.fileProc = new file_based_json_1.JsonFileProc(this.onFileEvent.bind(this));
-        Object.seal(this);
+async function makeOwnSendingParams(fs, fileName, anonInvites) {
+    let params = {};
+    let defaultParams = undefined;
+    const { file: paramsFile, changeProc } = await (0, single_file_1.initSyncedFile)(fs, fileName, newFile => newFile.writeJSON(currentToFileJSON()));
+    if (!paramsFile.isNew) {
+        ({ defaultParams, params } = parseFromJSON(await paramsFile.readJSON()));
     }
-    static async makeAndInit(file, anonInvites) {
-        const ownParams = new OwnSendingParams(anonInvites);
-        await ownParams.fileProc.start(file, () => ownParams.toFileJSON());
-        await ownParams.absorbChangesFromFile();
-        if (!ownParams.defaultParams) {
-            await ownParams.setDefaultParams();
-        }
-        return ownParams;
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(paramsFile, changeProc, onChangeFromOtherDevices, doOnConflict);
+    if (paramsFile.isNew) {
+        await setDefaultParams();
     }
-    async setDefaultParams() {
-        await this.fileProc.order.startOrChain(async () => {
-            const invites = this.anonInvites.getAll();
+    async function setDefaultParams() {
+        await changeProc.startOrChain(async () => {
+            const invites = anonInvites.getAll();
             const defaultInvite = invites.get(DEFAULT_INVITE_LABEL);
             if (defaultInvite) {
-                this.defaultParams = {
+                defaultParams = {
                     timestamp: 0,
                     invitation: defaultInvite.invite
                 };
             }
             else {
-                const invitation = await this.anonInvites.create(DEFAULT_INVITE_LABEL, DEFAULT_INVITE_MAX_MSG_SIZE);
-                this.defaultParams = {
+                const invitation = await anonInvites.create(DEFAULT_INVITE_LABEL, DEFAULT_INVITE_MAX_MSG_SIZE);
+                defaultParams = {
                     timestamp: 0,
                     invitation
                 };
             }
-            await this.persist();
+            await persist();
         });
     }
-    toFileJSON() {
+    function currentToFileJSON() {
         return {
-            default: this.defaultParams,
-            senderSpecific: Array.from(this.params.values())
+            default: defaultParams,
+            senderSpecific: Object.values(params)
         };
     }
-    async persist() {
-        await this.fileProc.save(this.toFileJSON(), false);
-    }
-    async absorbChangesFromFile() {
-        const { json } = await this.fileProc.get(false);
-        // we may add checks to json data
-        this.params.clear();
-        json.senderSpecific.forEach(p => this.params.set(p.address, p));
-        this.defaultParams = json.default;
+    async function persist() {
+        await paramsFile.writeJSON(currentToFileJSON());
+        triggerUpload();
     }
-    async onFileEvent(ev) {
-        if (ev.src === 'local') {
-            return;
+    function parseFromJSON(json) {
+        const params = {};
+        for (const p of json.senderSpecific) {
+            params[p.address] = p;
         }
-        if (ev.type === 'removed') {
-            throw new Error(`Unexpected removal of file with invites info`);
-        }
-        if (ev.type !== 'file-change') {
-            return;
-        }
-        await this.fileProc.order.startOrChain(() => this.absorbChangesFromFile());
+        return {
+            defaultParams: json.default,
+            params
+        };
+    }
+    function onChangeFromOtherDevices(newVersion) {
+        return changeProc.startOrChain(async () => {
+            const { version, json } = await paramsFile.v.readJSON();
+            if (version === newVersion) {
+                ({ defaultParams, params } = parseFromJSON(json));
+            }
+        });
+    }
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            const { remote, state } = await paramsFile.v.sync.status(false);
+            if ((state !== 'conflicting') || !(remote === null || remote === void 0 ? void 0 : remote.latest)) {
+                return;
+            }
+            const onRemote = parseFromJSON((await paramsFile.v.readJSON({ remoteVersion: remote.latest })).json);
+            let uploadLocal = false;
+            if (!onRemote.defaultParams && defaultParams) {
+                uploadLocal = true;
+            }
+            else if (onRemote.defaultParams && !defaultParams) {
+                defaultParams = onRemote.defaultParams;
+            }
+            else if (onRemote.defaultParams && defaultParams) {
+                if (onRemote.defaultParams.timestamp >= defaultParams.timestamp) {
+                    defaultParams = onRemote.defaultParams;
+                }
+                else {
+                    uploadLocal = true;
+                }
+            }
+            for (const [addr, p] of Object.entries(params)) {
+                const remP = onRemote.params[addr];
+                if (!remP) {
+                    uploadLocal = true;
+                    continue;
+                }
+                if ((0, json_utils_1.deepEqual)(p, remP)) {
+                    continue;
+                }
+                const tsP = Math.max((_b = (_a = p === null || p === void 0 ? void 0 : p.inUse) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : 0, (_d = (_c = p === null || p === void 0 ? void 0 : p.suggested) === null || _c === void 0 ? void 0 : _c.timestamp) !== null && _d !== void 0 ? _d : 0);
+                const tsRem = Math.max((_f = (_e = remP === null || remP === void 0 ? void 0 : remP.inUse) === null || _e === void 0 ? void 0 : _e.timestamp) !== null && _f !== void 0 ? _f : 0, (_h = (_g = remP === null || remP === void 0 ? void 0 : remP.suggested) === null || _g === void 0 ? void 0 : _g.timestamp) !== null && _h !== void 0 ? _h : 0);
+                if (tsP > tsRem) {
+                    uploadLocal = true;
+                }
+                else if (tsP < tsRem) {
+                    params[addr] = remP;
+                }
+                else if (tsP !== 0) {
+                    if (((_j = remP.inUse) === null || _j === void 0 ? void 0 : _j.timestamp) === tsP) {
+                        params[addr] = remP;
+                    }
+                    else if (((_k = p.inUse) === null || _k === void 0 ? void 0 : _k.timestamp) === tsP) {
+                        uploadLocal = true;
+                    }
+                }
+            }
+            if (uploadLocal) {
+                await paramsFile.writeJSON(currentToFileJSON());
+                await paramsFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+            }
+            else {
+                await paramsFile.v.sync.adoptRemote({ remoteVersion: remote.latest });
+            }
+        });
+    }
+    async function getUpdated(address) {
+        return changeProc.startOrChain(async () => {
+            let p = params[address];
+            if (p) {
+                if (p.suggested) {
+                    return p.suggested;
+                }
+                else if (p.inUse) {
+                    return; // undefined, cause params are known to correspondent,
+                    // and there are no params to suggest for future use.
+                }
+            }
+            // XXX Or, instead, should we set defaultParams?
+            if (!defaultParams) {
+                return;
+            }
+            p = {
+                address,
+                suggested: (0, json_utils_1.copy)(defaultParams)
+            };
+            p.suggested.timestamp = Date.now();
+            params[p.address] = p;
+            await persist();
+            return p.suggested;
+        });
+    }
+    function setAsUsed(address, invite) {
+        return changeProc.startOrChain(async () => {
+            const p = params[address];
+            if (!(p === null || p === void 0 ? void 0 : p.suggested) || (p.suggested.invitation !== invite)) {
+                return;
+            }
+            p.inUse = p.suggested;
+            p.suggested = undefined;
+            await persist();
+        });
     }
-    async close() {
-        await this.anonInvites.close();
-        await this.fileProc.close();
+    async function close() {
+        anonInvites.close();
+        stopFileWatching();
     }
+    return {
+        close,
+        getUpdated,
+        setAsUsed
+    };
 }
-exports.OwnSendingParams = OwnSendingParams;
-Object.freeze(OwnSendingParams.prototype);
-Object.freeze(OwnSendingParams);
 Object.freeze(exports);