core-3nweb-client-lib 0.39.0 → 0.40.1

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

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2016 - 2017, 2020, 2023 3NSoft Inc.
+ Copyright (C) 2016 - 2017, 2020, 2023, 2025 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
@@ -70,9 +70,10 @@ declare namespace web3n.startup {
 		 * @param progressCB is a callback for progress notification
 		 */
 		createUserParams(
-			pass: string,
-			progressCB: (progress: number) => void
+			pass: string, progressCB: ProgressCB
 		): Promise<void>;
+
+		watchBoot(observer: BootProcessObserver): () => void;
 		
 	}
 	
@@ -106,8 +107,7 @@ declare namespace web3n.startup {
 		 * @param progressCB is a callback for progress notification
 		 */
 		completeLoginAndLocalSetup(
-			pass: string,
-			progressCB: (progress: number) => void
+			pass: string, progressCB: ProgressCB
 		): Promise<boolean>;
 		
 		/**
@@ -119,12 +119,22 @@ declare namespace web3n.startup {
 		 * @param progressCB is a callback for progress notification
 		 */
 		useExistingStorage(
-			address: string, pass: string,
-			progressCB: (progress: number) => void
+			address: string, pass: string, progressCB: ProgressCB
 		): Promise<boolean>;
+
+		watchBoot(observer: BootProcessObserver): () => void;
 		
 	}
 
+	type ProgressCB = (progress: number) => void;
+	type BootProcessObserver = Observer<BootEvent>;
+	interface BootEvent {
+		coreApp?: string;
+		message: string;
+		isError?: true;
+		isWarning?: true;
+	}
+
 	interface W3N {
 		signIn: startup.SignInService;
 		signUp: startup.SignUpService;

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

@@ -87,24 +87,33 @@ class AnonymousInvites {
         });
         return serverJSON;
     }
-    async syncServiceSetting() {
+    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.
-        const infoOnServer = await this.anonInvitesOnServer.getFromServer()
-            .catch((exc) => {
-            if (exc.type === 'connect') {
-                return;
+        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);
             }
-            else {
-                throw exc;
+        }
+        catch (exc) {
+            if (!rethrowConnectExc
+                && (exc.type === 'connect')) {
+                return;
             }
-        });
-        const currentVal = this.toServiceJSON();
-        if (!(0, json_utils_1.deepEqual)(infoOnServer, currentVal)) {
-            await this.anonInvitesOnServer.setOnServer(currentVal);
+            throw exc;
         }
     }
     getAll() {

package/build/core/index.d.ts

@@ -20,13 +20,14 @@ export declare class Core {
     private asmail;
     private keyrings;
     private idManager;
-    private isInitialized;
     private closingProc;
+    private isInitialized;
     private constructor();
     static make(conf: CoreConf, makeNet: MakeNet, makeResolver: ServiceLocatorMaker, makeCryptor: makeCryptor): Core;
     start(): {
         capsForStartup: web3n.startup.W3N;
         coreInit: Promise<string>;
+        coreAppsInit: Promise<void>;
     };
     private initForNewUser;
     private initForExistingUserWithoutCache;
@@ -40,11 +41,9 @@ export declare class Core {
     private makeKeyringsCAP;
     private makeLogCAP;
     private makeMailerIdCAP;
-    private closeBroadcast;
-    close$: import("rxjs").Observable<void>;
     close(): Promise<void>;
     private performDataMigrationsAtInit;
-    private initCore;
+    private initCoreApps;
     getStorages(): FactoryOfFSs;
 }
 export {};

package/build/core/index.js

@@ -24,13 +24,12 @@ const sign_in_1 = require("./startup/sign-in");
 const asmail_1 = require("./asmail");
 const error_1 = require("../lib-common/exceptions/error");
 const json_utils_1 = require("../lib-common/json-utils");
-const rxjs_1 = require("rxjs");
 const log_to_file_1 = require("../lib-client/logging/log-to-file");
-const operators_1 = require("rxjs/operators");
 const app_files_1 = require("./app-files");
 const keyring_1 = require("./keyring");
 const constants_1 = require("./storage/common/constants");
 const config_1 = require("./asmail/config");
+const deferred_1 = require("../lib-common/processes/deferred");
 class Core {
     constructor(makeNet, makeResolver, makeCryptor, appDirs, logger, signUpUrl) {
         this.makeNet = makeNet;
@@ -39,95 +38,184 @@ class Core {
         this.logger = logger;
         this.signUpUrl = signUpUrl;
         this.idManager = undefined;
-        this.isInitialized = false;
         this.closingProc = undefined;
-        this.initForNewUser = async (u) => {
+        this.isInitialized = false;
+        this.cryptor = makeCryptor(this.logger.logError, this.logger.logWarning);
+        this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.appDirs.storagePathFor);
+        this.keyrings = new keyring_1.Keyrings(this.cryptor.cryptor.sbox);
+        this.asmail = new asmail_1.ASMail(this.cryptor.cryptor.sbox, this.makeNet, this.appDirs.inboxPathFor, this.logger);
+        Object.seal(this);
+    }
+    static make(conf, makeNet, makeResolver, makeCryptor) {
+        const dirs = (0, app_files_1.appDirs)(conf.dataDir);
+        const logger = (0, log_to_file_1.makeLogger)(dirs.getUtilFS());
+        const core = new Core(makeNet, makeResolver, makeCryptor, dirs, logger, conf.signUpUrl);
+        return core;
+    }
+    start() {
+        const { promise: midPromise, resolve: midDone } = (0, deferred_1.defer)();
+        const { watchBoot, emitBootEvent } = makeForBootEvents();
+        const signUp = new sign_up_1.SignUp(this.signUpUrl, this.cryptor.cryptor, this.makeNet, this.appDirs.getUsersOnDisk, user => this.initForNewUser(user, midDone, emitBootEvent), watchBoot, this.logger.logError);
+        const signIn = new sign_in_1.SignIn(this.cryptor.cryptor, addr => this.initForExistingUserWithoutCache(addr, midDone, emitBootEvent), (addr, storageKey) => this.initForExistingUserWithCache(addr, storageKey, midDone, emitBootEvent), this.appDirs.getUsersOnDisk, watchBoot, this.logger.logError);
+        const capsForStartup = {
+            signUp: signUp.exposedService(),
+            signIn: signIn.exposedService()
+        };
+        Object.freeze(capsForStartup);
+        const coreInit = midPromise.then(idManager => {
+            this.idManager = idManager;
+            return this.idManager.getId();
+        });
+        const coreAppsInit = coreInit.then(async () => {
+            // XXX This should be removed, at some point, as there will be no more
+            //     users with very old data folders.
+            await this.performDataMigrationsAtInit();
+            await this.initCoreApps(emitBootEvent);
+            this.isInitialized = true;
+        });
+        return { coreInit, coreAppsInit, capsForStartup };
+    }
+    ;
+    async initForNewUser(u, done, emitBootEvent) {
+        var _a;
+        emitBootEvent({
+            message: `Initializing system for new user ${u.address}`
+        });
+        try {
             // 1) init of id manager without setting fs
-            const stepTwo = await id_manager_1.IdManager.initWithoutStore(u.address, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            const stepTwo = await id_manager_1.IdManager.initWithoutStore(u.address, this.makeResolver('mailerid'), this.makeNet, this.logger.logError, this.logger.logWarning);
             if (!stepTwo) {
-                throw new Error(`MailerId server doesn't recognize identity ${u.address}`);
+                const message = `MailerId server doesn't recognize identity ${u.address}`;
+                emitBootEvent({ message, isError: true });
+                throw new Error(message);
             }
+            emitBootEvent({ message: `✔️  started login to provision MailerId` });
             // 2) complete id manager login, without use of fs
             const idManagerInit = await stepTwo(u.midSKey.default);
             if (!idManagerInit) {
-                throw new Error(`Failed to provision MailerId identity`);
+                const message = `Failed to provision MailerId identity`;
+                emitBootEvent({ message, isError: true });
+                throw new Error(message);
             }
+            emitBootEvent({ message: `✔️  MailerId certificate provisioned` });
             const { idManager, setupManagerStorage } = idManagerInit;
             // 3) initialize all storages
+            emitBootEvent({ message: `Setting up main storage for new user` });
             const storesUp = await this.storages.initFreshForNewUser(u.address, idManager.getSigner, u.storeParams, u.storeSKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
             if (!storesUp) {
-                throw new Error(`Stores failed to initialize`);
+                const message = `Main store failed to initialize for new user`;
+                emitBootEvent({ message, isError: true });
+                throw new Error(message);
             }
+            emitBootEvent({ message: `✔️  main storage initialized` });
             // 3) give id manager fs, in which it will record labeled key(s)
+            emitBootEvent({ coreApp: constants_1.MAILERID_APP_NAME, message: `setting up storage` });
             await setupManagerStorage(await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME), [u.midSKey.labeled]);
-            return idManager;
-        };
-        this.initForExistingUserWithoutCache = async (address) => {
+            emitBootEvent({ coreApp: constants_1.MAILERID_APP_NAME, message: `✔️  storage setup completed` });
+            done(idManager);
+        }
+        catch (exc) {
+            if (exc.type === 'connect') {
+                emitBootEvent({ message: `🔌  fail due to loss of connectivity`, isError: true });
+            }
+            else {
+                emitBootEvent({ message: (_a = exc.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(exc), isError: true });
+            }
+            throw exc;
+        }
+    }
+    async initForExistingUserWithoutCache(address, done, emitBootEvent) {
+        var _a;
+        emitBootEvent({
+            message: `Initializing system for user ${address}, without local cache on this device`
+        });
+        try {
             // 1) init of id manager without setting fs
-            const stepTwo = await id_manager_1.IdManager.initWithoutStore(address, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            const stepTwo = await id_manager_1.IdManager.initWithoutStore(address, this.makeResolver('mailerid'), this.makeNet, this.logger.logError, this.logger.logWarning);
             if (!stepTwo) {
+                emitBootEvent({
+                    isError: true, message: `MailerId server doesn't recognize identity ${address}`
+                });
                 return;
             }
             return async (midLoginKey, storageKey) => {
-                // 2) complete id manager login, without use of fs
-                const idManagerInit = await stepTwo(midLoginKey);
-                if (!idManagerInit) {
-                    return;
+                var _a;
+                try {
+                    // 2) complete id manager login, without use of fs
+                    const idManagerInit = await stepTwo(midLoginKey);
+                    if (!idManagerInit) {
+                        emitBootEvent({
+                            isError: true, message: `password/key is incorrect to provision MailerId certificate`
+                        });
+                        return false;
+                    }
+                    emitBootEvent({ message: `✔️  MailerId certificate provisioned` });
+                    const { idManager, setupManagerStorage } = idManagerInit;
+                    // 3) initialize all storages
+                    emitBootEvent({ message: `Setting up main storage without local cache` });
+                    const storeDone = await this.storages.initFromRemote(address, idManager.getSigner, storageKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
+                    if (!storeDone) {
+                        emitBootEvent({ message: `Main store failed to initialize`, isError: true });
+                        return false;
+                    }
+                    emitBootEvent({ message: `✔️  main storage initialized` });
+                    // 4) complete initialization of id manager
+                    emitBootEvent({ coreApp: constants_1.MAILERID_APP_NAME, message: `setting up storage` });
+                    await setupManagerStorage(await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME));
+                    emitBootEvent({ coreApp: constants_1.MAILERID_APP_NAME, message: `✔️  storage setup completed` });
+                    done(idManager);
+                    return true;
                 }
-                const { idManager, setupManagerStorage } = idManagerInit;
-                // 3) initialize all storages
-                const storeDone = await this.storages.initFromRemote(address, idManager.getSigner, storageKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
-                if (!storeDone) {
-                    return;
+                catch (exc) {
+                    if (exc.type === 'connect') {
+                        emitBootEvent({ message: `🔌  fail due to loss of connectivity`, isError: true });
+                    }
+                    else {
+                        emitBootEvent({ message: (_a = exc.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(exc), isError: true });
+                    }
+                    throw exc;
                 }
-                // 4) complete initialization of id manager
-                await setupManagerStorage(await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME));
-                return idManager;
             };
-        };
-        this.initForExistingUserWithCache = async (address, storageKey) => {
-            // XXX this shouldn't fail without network. All data is on the disk!
+        }
+        catch (exc) {
+            if (exc.type === 'connect') {
+                emitBootEvent({ message: `🔌  fail due to loss of connectivity`, isError: true });
+            }
+            else {
+                emitBootEvent({ message: (_a = exc.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(exc), isError: true });
+            }
+            throw exc;
+        }
+    }
+    async initForExistingUserWithCache(address, storageKey, done, emitBootEvent) {
+        var _a;
+        emitBootEvent({
+            message: `Initializing system for user ${address}, with local cache on this device`
+        });
+        try {
+            emitBootEvent({ message: `Unlocking data from local cache with provided password/key` });
             const completeStorageInit = await this.storages.startInitFromCache(address, storageKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
             if (!completeStorageInit) {
-                return;
+                emitBootEvent({
+                    isError: true, message: `password/key is incorrect to decrypt local caches, or caches are damaged`
+                });
+                return false;
             }
-            const idManager = await id_manager_1.IdManager.initFromCachedStore(address, await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME), this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            emitBootEvent({ message: `✔️  main storage is opened` });
+            const idManager = await id_manager_1.IdManager.initFromCachedStore(address, await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME), this.makeResolver('mailerid'), this.makeNet, this.logger.logError, this.logger.logWarning);
             if (!idManager) {
-                return;
+                return false;
             }
+            emitBootEvent({ message: `✔️  MailerId manager is initialized` });
             completeStorageInit(idManager.getSigner);
-            return idManager;
-        };
-        this.closeBroadcast = new rxjs_1.Subject();
-        this.close$ = this.closeBroadcast.asObservable();
-        this.cryptor = makeCryptor(this.logger.logError, this.logger.logWarning);
-        this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.appDirs.storagePathFor);
-        this.keyrings = new keyring_1.Keyrings(this.cryptor.cryptor.sbox);
-        this.asmail = new asmail_1.ASMail(this.cryptor.cryptor.sbox, this.makeNet, this.appDirs.inboxPathFor, this.logger);
-        Object.seal(this);
-    }
-    static make(conf, makeNet, makeResolver, makeCryptor) {
-        const dirs = (0, app_files_1.appDirs)(conf.dataDir);
-        const logger = (0, log_to_file_1.makeLogger)(dirs.getUtilFS());
-        const core = new Core(makeNet, makeResolver, makeCryptor, dirs, logger, conf.signUpUrl);
-        return core;
-    }
-    start() {
-        const signUp = new sign_up_1.SignUp(this.signUpUrl, this.cryptor.cryptor, this.makeNet.bind(this), this.appDirs.getUsersOnDisk, this.logger.logError);
-        const signIn = new sign_in_1.SignIn(this.cryptor.cryptor, this.initForExistingUserWithoutCache, this.initForExistingUserWithCache, this.appDirs.getUsersOnDisk, this.logger.logError);
-        const capsForStartup = {
-            signUp: signUp.exposedService(),
-            signIn: signIn.exposedService()
-        };
-        Object.freeze(capsForStartup);
-        const initFromSignUp$ = signUp.newUser$
-            .pipe((0, operators_1.mergeMap)(this.initForNewUser, 1));
-        const initFromSignIn$ = signIn.existingUser$;
-        const coreInit = (0, rxjs_1.lastValueFrom)((0, rxjs_1.merge)(initFromSignIn$, initFromSignUp$)
-            .pipe((0, operators_1.take)(1), (0, operators_1.mergeMap)(idManager => this.initCore(idManager), 1)));
-        return { coreInit, capsForStartup };
+            done(idManager);
+            return true;
+        }
+        catch (exc) {
+            emitBootEvent({ message: (_a = exc.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(exc), isError: true });
+            throw exc;
+        }
     }
-    ;
     makeCAPsForApp(appDomain, requestedCAPs) {
         if (!this.isInitialized || this.closingProc) {
             throw new Error(`Core is either not yet initialized, or is already closed.`);
@@ -204,7 +292,6 @@ class Core {
                 }
                 await this.cryptor.close();
                 this.cryptor = undefined;
-                this.closeBroadcast.next();
             })();
         }
         await this.closingProc;
@@ -214,27 +301,27 @@ class Core {
         await this.storages.migrateCoreAppDataOnFirstRun('synced', `${constants_1.ASMAIL_APP_NAME}/config/introductory-key.json`, `${constants_1.KEYRINGS_APP_NAME}/introductory-keys/published-on-server.json`);
         await this.storages.migrateCoreAppDataOnFirstRun('synced', `${constants_1.ASMAIL_APP_NAME}/config/anonymous/invites.json`, `${constants_1.ASMAIL_APP_NAME}/sending-params/anonymous-invites.json`);
     }
-    async initCore(idManager) {
+    async initCoreApps(emitBootEvent) {
+        var _a;
         try {
-            this.idManager = idManager;
             const address = this.idManager.getId();
             const getSigner = this.idManager.getSigner;
             const asmailServerConfig = new config_1.ConfigOfASMailServer(address, getSigner, this.makeResolver('asmail'), this.makeNet());
-            // XXX This should be removed, at some point, as there will be no more
-            //     users with very old data folders.
-            await this.performDataMigrationsAtInit();
-            // XXX some of these starting can be done any way
+            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'));
+            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);
             const inboxLocalFS = await this.storages.makeLocalFSForApp(constants_1.ASMAIL_APP_NAME);
             await this.asmail.init(this.idManager.getId(), this.idManager.getSigner, inboxSyncedFS, inboxLocalFS, this.storages.storageGetterForASMail(), this.makeResolver, asmailServerConfig, this.keyrings.forASMail());
-            this.isInitialized = true;
-            return this.idManager.getId();
+            emitBootEvent({ coreApp: constants_1.ASMAIL_APP_NAME, message: `✔️  initialized` });
         }
         catch (err) {
-            throw (0, error_1.errWithCause)(err, 'Failed to initialize core');
+            emitBootEvent({ isError: true, message: (_a = err.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(err) });
+            throw (0, error_1.errWithCause)(err, 'Failed to initialize core apps');
         }
+        emitBootEvent(true);
     }
     getStorages() {
         return this.storages.wrap();
@@ -243,6 +330,30 @@ class Core {
 exports.Core = Core;
 Object.freeze(Core.prototype);
 Object.freeze(Core);
+function makeForBootEvents() {
+    let bootProcObserver = undefined;
+    return {
+        watchBoot(obs) {
+            var _a;
+            if (bootProcObserver) {
+                (_a = bootProcObserver.error) === null || _a === void 0 ? void 0 : _a.call(bootProcObserver, `New observer is added, and it stops the previous one.`);
+            }
+            bootProcObserver = obs;
+            return () => {
+                bootProcObserver = undefined;
+            };
+        },
+        emitBootEvent(ev) {
+            var _a, _b;
+            if (ev === true) {
+                (_a = bootProcObserver === null || bootProcObserver === void 0 ? void 0 : bootProcObserver.complete) === null || _a === void 0 ? void 0 : _a.call(bootProcObserver);
+            }
+            else {
+                (_b = bootProcObserver === null || bootProcObserver === void 0 ? void 0 : bootProcObserver.next) === null || _b === void 0 ? void 0 : _b.call(bootProcObserver, ev);
+            }
+        }
+    };
+}
 function makeStoragePolicy(appDomain, requestedCAPs) {
     if (!requestedCAPs.storage) {
         throw new Error(`Missing storage setting in app's manifest`);

package/build/core/startup/sign-in.d.ts

@@ -1,29 +1,27 @@
-import type { IdManager } from '../id-manager';
 import { ScryptGenParams } from '../../lib-client/key-derivation';
 import type { GetUsersOnDisk } from '../app-files';
 import { Cryptor } from '../../lib-client/cryptor/cryptor';
 import { LogError } from '../../lib-client/logging/log-to-file';
 export type GenerateKey = (derivParams: ScryptGenParams) => Promise<Uint8Array>;
 export type StartInitWithoutCache = (address: string) => Promise<CompleteInitWithoutCache | undefined>;
-export type CompleteInitWithoutCache = (midLoginKey: GenerateKey, storageKey: GenerateKey) => Promise<IdManager | undefined>;
-export type InitWithCache = (address: string, storageKey: GenerateKey) => Promise<IdManager | undefined>;
+export type CompleteInitWithoutCache = (midLoginKey: GenerateKey, storageKey: GenerateKey) => Promise<boolean>;
+export type InitWithCache = (address: string, storageKey: GenerateKey) => Promise<boolean>;
 type SignInService = web3n.startup.SignInService;
+type ProgressCB = web3n.startup.ProgressCB;
 export declare class SignIn {
     private cryptor;
     private startInitWithoutCache;
     private initWithCache;
     private getUsersOnDisk;
+    private readonly watchBoot;
     private readonly logError;
     private completeInitWithoutCache;
-    constructor(cryptor: Cryptor, startInitWithoutCache: StartInitWithoutCache, initWithCache: InitWithCache, getUsersOnDisk: GetUsersOnDisk, logError: LogError);
+    constructor(cryptor: Cryptor, startInitWithoutCache: StartInitWithoutCache, initWithCache: InitWithCache, getUsersOnDisk: GetUsersOnDisk, watchBoot: SignInService['watchBoot'], logError: LogError);
     exposedService(): SignInService;
     private startLoginToRemoteStorage;
     private completeLoginAndLocalSetup;
-    private readonly doneBroadcast;
-    readonly existingUser$: import("rxjs").Observable<IdManager>;
     private useExistingStorage;
     private logAndWrap;
 }
-export type ProgressCB = (p: number) => void;
 export declare function makeKeyGenProgressCB(progressStart: number, progressEnd: number, progressCB: ProgressCB): ProgressCB;
 export {};

package/build/core/startup/sign-in.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2020, 2022 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 2020, 2022, 2025 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
@@ -19,75 +19,62 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignIn = void 0;
 exports.makeKeyGenProgressCB = makeKeyGenProgressCB;
 const key_derivation_1 = require("../../lib-client/key-derivation");
-const rxjs_1 = require("rxjs");
 const error_1 = require("../../lib-common/exceptions/error");
 class SignIn {
-    constructor(cryptor, startInitWithoutCache, initWithCache, getUsersOnDisk, logError) {
+    constructor(cryptor, startInitWithoutCache, initWithCache, getUsersOnDisk, watchBoot, logError) {
         this.cryptor = cryptor;
         this.startInitWithoutCache = startInitWithoutCache;
         this.initWithCache = initWithCache;
         this.getUsersOnDisk = getUsersOnDisk;
+        this.watchBoot = watchBoot;
         this.logError = logError;
         this.completeInitWithoutCache = undefined;
-        this.startLoginToRemoteStorage = async (address) => {
-            try {
-                this.completeInitWithoutCache = await this.startInitWithoutCache(address);
-                return !!this.completeInitWithoutCache;
-            }
-            catch (err) {
-                throw await this.logAndWrap(err, 'Fail to start login to remote storage');
-            }
-        };
-        this.completeLoginAndLocalSetup = async (pass, progressCB) => {
-            if (!this.completeInitWithoutCache) {
-                throw new Error(`Call method startLoginToRemoteStorage() before calling this.`);
-            }
-            try {
-                const midKeyProgressCB = makeKeyGenProgressCB(0, 50, progressCB);
-                const midKeyGen = async (params) => (await (0, key_derivation_1.deriveMidKeyPair)(this.cryptor, pass, params, midKeyProgressCB)).skey;
-                const storeKeyProgressCB = makeKeyGenProgressCB(51, 100, progressCB);
-                const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
-                const idManager = await this.completeInitWithoutCache(midKeyGen, storeKeyGen);
-                if (!idManager) {
-                    return false;
-                }
-                this.doneBroadcast.next(idManager);
-                return true;
-            }
-            catch (err) {
-                throw await this.logAndWrap(err, 'Fail to initialize from a state without cache');
-            }
-        };
-        this.doneBroadcast = new rxjs_1.Subject();
-        this.existingUser$ = this.doneBroadcast.asObservable();
-        this.useExistingStorage = async (user, pass, progressCB) => {
-            try {
-                const storeKeyProgressCB = makeKeyGenProgressCB(0, 99, progressCB);
-                const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
-                const idManager = await this.initWithCache(user, storeKeyGen);
-                if (idManager) {
-                    this.doneBroadcast.next(idManager);
-                    return true;
-                }
-                else {
-                    return false;
-                }
-            }
-            catch (err) {
-                throw await this.logAndWrap(err, 'Failing to start in a state with cache');
-            }
-        };
         Object.seal(this);
     }
     exposedService() {
         const service = {
-            completeLoginAndLocalSetup: this.completeLoginAndLocalSetup,
+            completeLoginAndLocalSetup: this.completeLoginAndLocalSetup.bind(this),
             getUsersOnDisk: this.getUsersOnDisk,
-            startLoginToRemoteStorage: this.startLoginToRemoteStorage,
-            useExistingStorage: this.useExistingStorage
+            startLoginToRemoteStorage: this.startLoginToRemoteStorage.bind(this),
+            useExistingStorage: this.useExistingStorage.bind(this),
+            watchBoot: this.watchBoot
         };
         return Object.freeze(service);
     }
+    async startLoginToRemoteStorage(address) {
+        try {
+            this.completeInitWithoutCache = await this.startInitWithoutCache(address);
+            return !!this.completeInitWithoutCache;
+        }
+        catch (err) {
+            throw await this.logAndWrap(err, 'Fail to start login to remote storage');
+        }
+    }
+    async completeLoginAndLocalSetup(pass, progressCB) {
+        if (!this.completeInitWithoutCache) {
+            throw new Error(`Call method startLoginToRemoteStorage() before calling this.`);
+        }
+        try {
+            const midKeyProgressCB = makeKeyGenProgressCB(0, 50, progressCB);
+            const midKeyGen = async (params) => (await (0, key_derivation_1.deriveMidKeyPair)(this.cryptor, pass, params, midKeyProgressCB)).skey;
+            const storeKeyProgressCB = makeKeyGenProgressCB(51, 100, progressCB);
+            const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
+            return await this.completeInitWithoutCache(midKeyGen, storeKeyGen);
+        }
+        catch (err) {
+            throw await this.logAndWrap(err, 'Fail to initialize from a state without cache');
+        }
+    }
+    async useExistingStorage(user, pass, progressCB) {
+        try {
+            const storeKeyProgressCB = makeKeyGenProgressCB(0, 99, progressCB);
+            const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
+            return await this.initWithCache(user, storeKeyGen);
+        }
+        catch (err) {
+            throw await this.logAndWrap(err, 'Failing to start in a state with cache');
+        }
+    }
     async logAndWrap(err, msg) {
         await this.logError(err, msg);
         return (0, error_1.errWithCause)(err, msg);

package/build/core/startup/sign-up.d.ts

@@ -15,14 +15,18 @@ export declare class SignUp {
     private cryptor;
     private makeNet;
     private getUsersOnDisk;
+    private initForNewUser;
+    private readonly watchBoot;
     private readonly logError;
     private mid;
     private store;
     private serviceURL;
     private netLazyInit;
     private get net();
-    constructor(serviceURL: string, cryptor: Cryptor, makeNet: () => NetClient, getUsersOnDisk: GetUsersOnDisk, logError: LogError);
+    constructor(serviceURL: string, cryptor: Cryptor, makeNet: () => NetClient, getUsersOnDisk: GetUsersOnDisk, initForNewUser: (u: CreatedUser) => Promise<void>, watchBoot: SignUpService['watchBoot'], logError: LogError);
     private setServiceURL;
+    private getAvailableDomains;
+    private getAvailableAddresses;
     exposedService(): SignUpService;
     private createUserParams;
     private genStorageParams;
@@ -30,8 +34,6 @@ export declare class SignUp {
     private addUser;
     private logAndWrap;
     private forgetKeys;
-    private doneBroadcast;
-    newUser$: import("rxjs").Observable<CreatedUser>;
 }
 export interface CreatedUser {
     address: string;

package/build/core/startup/sign-up.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020, 2022 - 2023 3NSoft Inc.
+ Copyright (C) 2015 - 2020, 2022 - 2023, 2025 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
@@ -26,7 +26,6 @@ const keyDeriv = require("../../lib-client/key-derivation");
 const random = require("../../lib-common/random-node");
 const ecma_nacl_1 = require("ecma-nacl");
 const sign_in_1 = require("./sign-in");
-const rxjs_1 = require("rxjs");
 const error_1 = require("../../lib-common/exceptions/error");
 /**
  * With these parameters scrypt shall use memory around:
@@ -63,54 +62,21 @@ class SignUp {
         }
         return this.netLazyInit;
     }
-    constructor(serviceURL, cryptor, makeNet, getUsersOnDisk, logError) {
+    constructor(serviceURL, cryptor, makeNet, getUsersOnDisk, initForNewUser, watchBoot, logError) {
         this.cryptor = cryptor;
         this.makeNet = makeNet;
         this.getUsersOnDisk = getUsersOnDisk;
+        this.initForNewUser = initForNewUser;
+        this.watchBoot = watchBoot;
         this.logError = logError;
         this.mid = undefined;
         this.store = undefined;
         this.serviceURL = undefined;
         this.netLazyInit = undefined;
-        this.createUserParams = async (pass, progressCB) => {
-            await this.genMidParams(pass, 0, 50, progressCB);
-            await this.genStorageParams(pass, 51, 100, progressCB);
-        };
-        this.addUser = async (address, signupToken) => {
-            for (const user of await this.getUsersOnDisk()) {
-                if ((0, canonical_address_1.areAddressesEqual)(address, user)) {
-                    throw new Error(`Account ${user} already exists on a disk.`);
-                }
-            }
-            const accountCreated = await (0, _3nweb_signup_1.addUser)(this.net, this.serviceURL, {
-                userId: address,
-                mailerId: this.mid.params,
-                storage: this.store.params,
-                signupToken
-            }).catch(async (err) => {
-                throw await this.logAndWrap(err, `Failed to create user account ${address}.`);
-            });
-            if (!accountCreated) {
-                return false;
-            }
-            this.doneBroadcast.next({
-                address,
-                midSKey: {
-                    default: this.mid.defaultSKey,
-                    labeled: this.mid.labeledSKey
-                },
-                storeSKey: this.store.skey,
-                storeParams: this.store.params.kdParams
-            });
-            this.forgetKeys();
-            return true;
-        };
-        this.doneBroadcast = new rxjs_1.Subject();
-        this.newUser$ = this.doneBroadcast.asObservable();
         this.setServiceURL(serviceURL);
         Object.seal(this);
     }
-    setServiceURL(serviceURL) {
+    async setServiceURL(serviceURL) {
         const url = (0, url_1.parse)(serviceURL);
         if (url.protocol !== 'https:') {
             throw new Error("Url protocol must be https.");
@@ -120,17 +86,28 @@ class SignUp {
             this.serviceURL += '/';
         }
     }
+    async getAvailableDomains(signupToken) {
+        return await (0, _3nweb_signup_1.checkAvailableDomains)(this.net, this.serviceURL, signupToken);
+    }
+    async getAvailableAddresses(name, signupToken) {
+        return await (0, _3nweb_signup_1.checkAvailableAddressesForName)(this.net, this.serviceURL, name, signupToken);
+    }
     exposedService() {
         const service = {
-            setSignUpServer: async (srvUrl) => this.setServiceURL(srvUrl),
-            getAvailableDomains: signupToken => (0, _3nweb_signup_1.checkAvailableDomains)(this.net, this.serviceURL, signupToken),
-            addUser: this.addUser,
-            createUserParams: this.createUserParams,
-            getAvailableAddresses: (name, signupToken) => (0, _3nweb_signup_1.checkAvailableAddressesForName)(this.net, this.serviceURL, name, signupToken),
-            isActivated: async () => { throw new Error(`Not implemented, yet`); }
+            setSignUpServer: this.setServiceURL.bind(this),
+            getAvailableDomains: this.getAvailableDomains.bind(this),
+            addUser: this.addUser.bind(this),
+            createUserParams: this.createUserParams.bind(this),
+            getAvailableAddresses: this.getAvailableAddresses.bind(this),
+            isActivated: () => { throw new Error(`Not implemented, yet`); },
+            watchBoot: this.watchBoot
         };
         return Object.freeze(service);
     }
+    async createUserParams(pass, progressCB) {
+        await this.genMidParams(pass, 0, 50, progressCB);
+        await this.genStorageParams(pass, 51, 100, progressCB);
+    }
     async genStorageParams(pass, progressStart, progressEnd, originalProgressCB) {
         const derivParams = {
             logN: defaultDerivParams.logN,
@@ -169,6 +146,35 @@ class SignUp {
             }
         };
     }
+    async addUser(address, signupToken) {
+        for (const user of await this.getUsersOnDisk()) {
+            if ((0, canonical_address_1.areAddressesEqual)(address, user)) {
+                throw new Error(`Account ${user} already exists on a disk.`);
+            }
+        }
+        const accountCreated = await (0, _3nweb_signup_1.addUser)(this.net, this.serviceURL, {
+            userId: address,
+            mailerId: this.mid.params,
+            storage: this.store.params,
+            signupToken
+        }).catch(async (err) => {
+            throw await this.logAndWrap(err, `Failed to create user account ${address}.`);
+        });
+        if (!accountCreated) {
+            return false;
+        }
+        this.initForNewUser({
+            address,
+            midSKey: {
+                default: this.mid.defaultSKey,
+                labeled: this.mid.labeledSKey
+            },
+            storeSKey: this.store.skey,
+            storeParams: this.store.params.kdParams
+        });
+        this.forgetKeys();
+        return true;
+    }
     async logAndWrap(err, msg) {
         await this.logError(err, msg);
         return (0, error_1.errWithCause)(err, msg);

package/build/core/startup/startup-cap.js

@@ -44,7 +44,8 @@ function wrapSignInCAP(cap) {
                 (_b = obs.complete) === null || _b === void 0 ? void 0 : _b.call(obs);
             }, err => { var _a; return (_a = obs.error) === null || _a === void 0 ? void 0 : _a.call(obs, err); });
             return noop;
-        })
+        }),
+        watchBoot: (0, service_side_wrap_1.wrapObservingFunc)(cap.watchBoot)
     };
 }
 function makeSignInCaller(caller, objPath) {
@@ -66,7 +67,8 @@ function makeSignInCaller(caller, objPath) {
                 obsFn(obs, addr, pass);
                 return promise;
             };
-        })()
+        })(),
+        watchBoot: (0, caller_side_wrap_1.makeObservableFuncCaller)(caller, objPath.concat('watchBoot'))
     };
 }
 function callSignIn(caller, objPath, method) {
@@ -104,7 +106,8 @@ function wrapSignUpCAP(cap) {
                 .then(() => { var _a; return (_a = obs.complete) === null || _a === void 0 ? void 0 : _a.call(obs); }, err => { var _a; return (_a = obs.error) === null || _a === void 0 ? void 0 : _a.call(obs, err); });
             return noop;
         }),
-        isActivated: (0, service_side_wrap_1.wrapReqReplySrvMethod)(cap, 'isActivated')
+        isActivated: (0, service_side_wrap_1.wrapReqReplySrvMethod)(cap, 'isActivated'),
+        watchBoot: (0, service_side_wrap_1.wrapObservingFunc)(cap.watchBoot)
     };
 }
 function noop() { }
@@ -129,7 +132,8 @@ function makeSignUpCaller(caller, objPath) {
                 return completion.promise;
             };
         })(),
-        isActivated: callSignUp(caller, objPath, 'isActivated')
+        isActivated: callSignUp(caller, objPath, 'isActivated'),
+        watchBoot: (0, caller_side_wrap_1.makeObservableFuncCaller)(caller, objPath.concat('watchBoot'))
     };
 }
 Object.freeze(exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-3nweb-client-lib",
-  "version": "0.39.0",
+  "version": "0.40.1",
   "description": "3NWeb client core library, embeddable into different environments",
   "main": "build/lib-index.js",
   "types": "build/lib-index.d.ts",