core-3nweb-client-lib 0.27.1 → 0.27.3

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

@@ -18,10 +18,13 @@
 
 declare namespace web3n.files {
 
-	interface FileException extends RuntimeException {
+	interface FileException extends RuntimeException, FileExceptionFlag {
 		type: 'file';
 		code: string|undefined;
 		path: string;
+	}
+
+	interface FileExceptionFlag {
 		notFound?: true;
 		alreadyExists?: true;
 		notDirectory?: true;
@@ -48,19 +51,13 @@ declare namespace web3n.files {
 		alreadyExists: 'EEXIST';
 		notDirectory: 'ENOTDIR';
 		notFile: 'ENOTFILE';
-		notLink: 'not-link';
 		isDirectory: 'EISDIR';
 		notEmpty: 'ENOTEMPTY';
 		endOfFile: 'EEOF';
 		opNotPermitted: 'EPERM';
 		busy: 'EBUSY';
 		ioError: 'EIO';
-		concurrentUpdate: 'concurrent-update';
-		parsingError: 'parsing-error';
 		notImplemented: 'ENOSYS';
-		isEndless: 'is-endless';
-		storageClosed: 'storage-closed';
-		versionMismatch: 'version-mismatch';
 	}
 
 	interface FSSyncException extends RuntimeException {

package/build/core/asmail/inbox/attachments/fs.d.ts

@@ -1,6 +1,7 @@
 import { StorageGetter, FolderInJSON } from '../../../../lib-client/3nstorage/xsp-fs/common';
 import { AsyncSBoxCryptor } from 'xsp-files';
 import { MsgOnDisk } from '../msg-on-disk';
+import { LogError } from '../../../../lib-client/logging/log-to-file';
 declare type ReadonlyFS = web3n.files.ReadonlyFS;
-export declare function fsForAttachments(msg: MsgOnDisk, rootJson: FolderInJSON, storages: StorageGetter, cryptor: AsyncSBoxCryptor): ReadonlyFS;
+export declare function fsForAttachments(msg: MsgOnDisk, rootJson: FolderInJSON, storages: StorageGetter, cryptor: AsyncSBoxCryptor, logError: LogError): ReadonlyFS;
 export {};

package/build/core/asmail/inbox/attachments/fs.js

@@ -20,10 +20,11 @@ exports.fsForAttachments = void 0;
 const common_1 = require("../../../../lib-client/3nstorage/xsp-fs/common");
 const fs_1 = require("../../../../lib-client/3nstorage/xsp-fs/fs");
 class AttachmentStore {
-    constructor(msg, getStorages, cryptor) {
+    constructor(msg, getStorages, cryptor, logError) {
         this.msg = msg;
         this.getStorages = getStorages;
         this.cryptor = cryptor;
+        this.logError = logError;
         this.type = 'asmail-msg';
         this.versioned = false;
         this.nodes = new common_1.NodesContainer();
@@ -66,8 +67,8 @@ class AttachmentStore {
 }
 Object.freeze(AttachmentStore.prototype);
 Object.freeze(AttachmentStore);
-function fsForAttachments(msg, rootJson, storages, cryptor) {
-    const storage = new AttachmentStore(msg, storages, cryptor);
+function fsForAttachments(msg, rootJson, storages, cryptor, logError) {
+    const storage = new AttachmentStore(msg, storages, cryptor, logError);
     const fs = fs_1.XspFS.fromASMailMsgRootFromJSON(storage, rootJson, 'attachments');
     return fs;
 }

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

@@ -297,7 +297,7 @@ class InboxOnServer {
         }
         const attachments = msg.attachmentsJSON;
         if (attachments) {
-            m.attachments = (0, fs_1.fsForAttachments)(msgOnDisk, attachments, this.storages, this.cryptor);
+            m.attachments = (0, fs_1.fsForAttachments)(msgOnDisk, attachments, this.storages, this.cryptor, this.logError);
         }
         return m;
     }

package/build/core/id-manager/index.d.ts

@@ -0,0 +1,43 @@
+import { user as mid } from '../../lib-common/mid-sigs-NaCl-Ed';
+import { JsonKey } from '../../lib-common/jwkeys';
+import { GenerateKey } from '../sign-in';
+import { LogError, LogWarning } from '../../lib-client/logging/log-to-file';
+import { NetClient } from '../../lib-client/request-utils';
+import { ServiceLocator } from '../../lib-client/service-locator';
+declare type WritableFS = web3n.files.WritableFS;
+/**
+ * This function completes provisioning process, returning a promise, resolvable
+ * to either true, when all is done, or to false, when challenge reply is not
+ * accepted by the server.
+ */
+export interface CompleteProvisioning {
+    keyParams: any;
+    complete(defaultSKey: Uint8Array): Promise<boolean>;
+}
+/**
+ * This returns a promise, resolvable to mailerId signer.
+ */
+export declare type GetSigner = () => Promise<mid.MailerIdSigner>;
+export declare type SetupManagerStorage = (fs: WritableFS, keysToSave?: JsonKey[]) => Promise<void>;
+export declare class IdManager {
+    private readonly store;
+    private readonly makeNet;
+    private readonly midServiceFor;
+    private address;
+    private signer;
+    private provisioningProc;
+    private constructor();
+    static initWithoutStore(address: string, resolver: ServiceLocator, makeNet: () => NetClient, logError: LogError, logWarning: LogWarning): Promise<((midLoginKey: GenerateKey | Uint8Array) => Promise<{
+        idManager: IdManager;
+        setupManagerStorage: SetupManagerStorage;
+    } | undefined>) | undefined>;
+    static initFromCachedStore(address: string, fs: WritableFS, resolver: ServiceLocator, makeNet: () => NetClient, logError: LogError, logWarning: LogWarning): Promise<IdManager | undefined>;
+    private startProvisionWithoutSavedKey;
+    private provisionUsingSavedKey;
+    getId(): string;
+    getSigner: GetSigner;
+    isProvisionedAndValid(): boolean;
+    makeMailerIdCAP(): Service;
+}
+declare type Service = web3n.mailerid.Service;
+export {};

package/build/core/{id-manager.js → id-manager/index.js}

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2020 - 2021 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 2020 - 2022 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
@@ -18,24 +18,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdManager = void 0;
 const ecma_nacl_1 = require("ecma-nacl");
-const provisioner_1 = require("../lib-client/mailer-id/provisioner");
-const jwkeys_1 = require("../lib-common/jwkeys");
-const synced_1 = require("../lib-common/processes/synced");
-const login_1 = require("../lib-client/mailer-id/login");
+const provisioner_1 = require("../../lib-client/mailer-id/provisioner");
+const jwkeys_1 = require("../../lib-common/jwkeys");
+const synced_1 = require("../../lib-common/processes/synced");
+const login_1 = require("../../lib-client/mailer-id/login");
+const key_storage_1 = require("./key-storage");
 const CERTIFICATE_DURATION_SECONDS = 16 * 60 * 60;
 const ASSERTION_VALIDITY = 15 * 60;
 const MIN_SECS_LEFT_ASSUMED_OK = 10 * 60;
-const LOGIN_KEY_FILE_NAME = 'login-keys';
 class IdManager {
-    constructor(makeNet, midServiceFor, logError, logWarning, address, localFS) {
+    constructor(store, makeNet, midServiceFor, address) {
+        this.store = store;
         this.makeNet = makeNet;
         this.midServiceFor = midServiceFor;
-        this.logError = logError;
-        this.logWarning = logWarning;
         this.address = address;
         this.signer = undefined;
-        this.localFS = undefined;
-        this.syncedFS = undefined;
         this.provisioningProc = new synced_1.SingleProc();
         this.getSigner = async () => {
             if (!this.address) {
@@ -46,117 +43,46 @@ class IdManager {
             }
             return this.signer;
         };
-        if (localFS) {
-            this.localFS = localFS;
-        }
         Object.seal(this);
     }
-    static async initInOneStepWithoutStore(address, midLoginKey, resolver, makeNet, logError, logWarning) {
-        const stepTwo = await IdManager.initWithoutStore(address, resolver, makeNet, logError, logWarning);
-        if (!stepTwo) {
-            throw new Error(`MailerId server doesn't recognize identity ${address}`);
-        }
-        return stepTwo(midLoginKey);
-    }
     static async initWithoutStore(address, resolver, makeNet, logError, logWarning) {
-        const idManager = new IdManager(makeNet, resolver, logError, logWarning, address);
-        const completion = await idManager.provisionWithGivenKey(address);
-        if (!completion) {
+        const { store, setupManagerStorage } = key_storage_1.IdKeysStorage.makeWithoutStorage(logError, logWarning);
+        const idManager = new IdManager(store, makeNet, resolver, address);
+        const provisioning = await idManager.startProvisionWithoutSavedKey(address);
+        if (!provisioning) {
             return;
         }
         return async (midLoginKey) => {
             const key = ((typeof midLoginKey === 'function') ?
-                await midLoginKey(completion.keyParams) :
+                await midLoginKey(provisioning.keyParams) :
                 midLoginKey);
-            const isDone = await completion.complete(key);
+            const isDone = await provisioning.complete(key);
             key.fill(0);
-            return (isDone ? idManager : undefined);
+            if (!isDone) {
+                return;
+            }
+            return {
+                idManager,
+                setupManagerStorage: (fs, keys) => setupManagerStorage(fs, (keys ? {
+                    address: idManager.address,
+                    keys
+                } : undefined))
+            };
         };
     }
-    static async initFromLocalStore(address, localFS, resolver, makeNet, logError, logWarning) {
-        const idMan = new IdManager(makeNet, resolver, logError, logWarning, address);
-        if (localFS.type !== 'local') {
-            throw new Error(`Expected local storage is typed as ${localFS.type}`);
-        }
-        idMan.localFS = localFS;
+    static async initFromCachedStore(address, fs, resolver, makeNet, logError, logWarning) {
+        const store = key_storage_1.IdKeysStorage.makeWithStorage(fs, logError, logWarning);
+        const idManager = new IdManager(store, makeNet, resolver, address);
         try {
-            await idMan.provisionUsingSavedKey();
+            await idManager.provisionUsingSavedKey();
+            return idManager;
         }
         catch (err) {
             await logError(err, `Can't initialize id manager from local store`);
             return;
         }
-        return idMan;
-    }
-    async ensureLocalCacheOfKeys() {
-        if (!this.localFS || !this.syncedFS) {
-            throw new Error(`Id manager's storages are not set.`);
-        }
-        const keysCached = await this.localFS.checkFilePresence(LOGIN_KEY_FILE_NAME);
-        if (keysCached) {
-            return;
-        }
-        try {
-            const bytes = await this.syncedFS.readBytes(LOGIN_KEY_FILE_NAME);
-            await this.localFS.writeBytes(LOGIN_KEY_FILE_NAME, bytes);
-            bytes.fill(0);
-        }
-        catch (err) {
-            await this.logError(err, `Fail to ensure local cache of MailerId login keys.`);
-        }
-    }
-    async getSavedKey() {
-        if (!this.localFS) {
-            throw new Error(`Id manager's local storage is not set.`);
-        }
-        const json = await this.localFS.readJSONFile(LOGIN_KEY_FILE_NAME).catch(notFoundOrReThrow);
-        if (json) {
-            return json.keys[0];
-        }
-        if (this.syncedFS) {
-            const json = await this.syncedFS.readJSONFile(LOGIN_KEY_FILE_NAME).catch(notFoundOrReThrow);
-            if (json) {
-                await this.ensureLocalCacheOfKeys();
-                return json.keys[0];
-            }
-            else {
-                await this.logWarning(`IdManager: there is no login MailerId login keys`);
-            }
-        }
-        return;
-    }
-    async setStorages(localFS, syncedFS, keysToSave) {
-        if (localFS) {
-            if (localFS.type !== 'local') {
-                throw new Error(`Expected local storage is typed as ${localFS.type}`);
-            }
-            this.localFS = localFS;
-        }
-        else {
-            if (!this.localFS) {
-                throw new Error(`Local storage is not given`);
-            }
-        }
-        if (syncedFS.type !== 'synced') {
-            throw new Error(`Expected synced storage is typed as ${syncedFS.type}`);
-        }
-        this.syncedFS = syncedFS;
-        if (keysToSave) {
-            const json = {
-                address: this.address,
-                keys: keysToSave
-            };
-            await this.localFS.writeJSONFile(LOGIN_KEY_FILE_NAME, json);
-            await this.syncedFS.writeJSONFile(LOGIN_KEY_FILE_NAME, json);
-            // XXX must add work with not-online condition
-            await this.syncedFS.v.sync.upload(LOGIN_KEY_FILE_NAME);
-            await this.syncedFS.v.sync.upload('');
-        }
-        else {
-            await this.ensureLocalCacheOfKeys();
-        }
     }
-    async provisionWithGivenKey(address) {
+    async startProvisionWithoutSavedKey(address) {
         const midUrl = await this.midServiceFor(address);
         const provisioner = new provisioner_1.MailerIdProvisioner(address, midUrl, this.makeNet());
         try {
@@ -202,7 +128,7 @@ class IdManager {
         proc = this.provisioningProc.start(async () => {
             const midUrl = await this.midServiceFor(this.address);
             const provisioner = new provisioner_1.MailerIdProvisioner(this.address, midUrl, this.makeNet());
-            const key = await this.getSavedKey();
+            const key = await this.store.getSavedKey();
             if (!key) {
                 throw new Error(`No saved MailerId login key can be found`);
             }
@@ -245,15 +171,8 @@ class IdManager {
     }
 }
 exports.IdManager = IdManager;
-/**
- * This is a catch callback, which returns undefined on file(folder) not found
- * exception, and re-throws all other exceptions/errors.
- */
-function notFoundOrReThrow(exc) {
-    if (!exc.notFound) {
-        throw exc;
-    }
-}
+Object.freeze(IdManager.prototype);
+Object.freeze(IdManager);
 async function doMidLogin(loginUrl, userId, net, signer) {
     const { sessionId, redirect } = await (0, login_1.startMidSession)(userId, net, loginUrl);
     if (!sessionId) {

package/build/core/id-manager/key-storage.d.ts

@@ -0,0 +1,21 @@
+import { LogError, LogWarning } from "../../lib-client/logging/log-to-file";
+import { JsonKey } from "../../lib-common/jwkeys";
+declare type WritableFS = web3n.files.WritableFS;
+export interface LoginKeysJSON {
+    address: string;
+    keys: JsonKey[];
+}
+export declare class IdKeysStorage {
+    private readonly logError;
+    private readonly logWarning;
+    private fs;
+    private constructor();
+    static makeWithStorage(fs: WritableFS, logError: LogError, logWarning: LogWarning): IdKeysStorage;
+    static makeWithoutStorage(logError: LogError, logWarning: LogWarning): {
+        store: IdKeysStorage;
+        setupManagerStorage: (fs: WritableFS, keysToSave?: LoginKeysJSON) => Promise<void>;
+    };
+    getSavedKey(): Promise<JsonKey | undefined>;
+    private setStorageFS;
+}
+export {};

package/build/core/id-manager/key-storage.js

@@ -0,0 +1,96 @@
+"use strict";
+/*
+ Copyright (C) 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdKeysStorage = void 0;
+const assert_1 = require("../../lib-common/assert");
+const error_1 = require("../../lib-common/exceptions/error");
+const LOGIN_KEY_FILE_NAME = 'login-keys';
+class IdKeysStorage {
+    constructor(logError, logWarning, fs) {
+        this.logError = logError;
+        this.logWarning = logWarning;
+        this.fs = undefined;
+        if (fs) {
+            (0, assert_1.assert)(fs.type === 'synced');
+            this.fs = fs;
+        }
+        Object.seal(this);
+    }
+    static makeWithStorage(fs, logError, logWarning) {
+        return new IdKeysStorage(logError, logWarning, fs);
+    }
+    static makeWithoutStorage(logError, logWarning) {
+        const store = new IdKeysStorage(logError, logWarning);
+        return {
+            store,
+            setupManagerStorage: (fs, keys) => store.setStorageFS(fs, keys)
+        };
+    }
+    async getSavedKey() {
+        var _a, _b;
+        if (!((_b = (_a = this.fs) === null || _a === void 0 ? void 0 : _a.v) === null || _b === void 0 ? void 0 : _b.sync)) {
+            throw new Error(`Id manager's storages are not set.`);
+        }
+        try {
+            const json = await this.fs.readJSONFile(LOGIN_KEY_FILE_NAME);
+            return json.keys[0];
+        }
+        catch (exc) {
+            if (!exc.notFound) {
+                throw exc;
+            }
+            await this.fs.v.sync.updateStatusInfo('');
+            await this.fs.v.sync.adoptRemote('');
+            if (await this.fs.checkFilePresence(LOGIN_KEY_FILE_NAME)) {
+                return this.getSavedKey();
+            }
+            else {
+                await this.logWarning(`IdManager: no saved login MailerId keys`);
+                return;
+            }
+        }
+    }
+    async setStorageFS(fs, keysToSave) {
+        (0, assert_1.assert)(!this.fs);
+        (0, assert_1.assert)(fs.type === 'synced');
+        this.fs = fs;
+        if (keysToSave) {
+            await this.fs.writeJSONFile(LOGIN_KEY_FILE_NAME, keysToSave);
+            // XXX must add work with not-online condition
+            await this.fs.v.sync.upload(LOGIN_KEY_FILE_NAME);
+            await this.fs.v.sync.upload('');
+        }
+        else {
+            try {
+                await this.fs.readJSONFile(LOGIN_KEY_FILE_NAME);
+            }
+            catch (exc) {
+                throw (0, error_1.errWithCause)(exc, `Fail expection read of login MailerId keys from the storage`);
+            }
+        }
+    }
+}
+exports.IdKeysStorage = IdKeysStorage;
+Object.freeze(IdKeysStorage.prototype);
+Object.freeze(IdKeysStorage);
+function notFoundOrReThrow(exc) {
+    if (!exc.notFound) {
+        throw exc;
+    }
+}
+Object.freeze(exports);

package/build/core/index.js

@@ -42,17 +42,23 @@ class Core {
         this.closingProc = undefined;
         this.initForNewUser = async (u) => {
             // 1) init of id manager without setting fs
-            const idManager = await id_manager_1.IdManager.initInOneStepWithoutStore(u.address, u.midSKey.default, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
-            if (!idManager) {
+            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}`);
+            }
+            // 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`);
             }
-            // 2) setup storage
-            const storesUp = await this.storages.initFromRemote(u.address, idManager.getSigner, u.storeSKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
+            const { idManager, setupManagerStorage } = idManagerInit;
+            // 3) initialize all storages
+            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`);
             }
             // 3) give id manager fs, in which it will record labeled key(s)
-            await idManager.setStorages(await this.storages.makeLocalFSForApp(MAILERID_APP_NAME), await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME), [u.midSKey.labeled]);
+            await setupManagerStorage(await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME), [u.midSKey.labeled]);
             return idManager;
         };
         this.initForExistingUserWithoutCache = async (address) => {
@@ -63,17 +69,18 @@ class Core {
             }
             return async (midLoginKey, storageKey) => {
                 // 2) complete id manager login, without use of fs
-                const idManager = await stepTwo(midLoginKey);
-                if (!idManager) {
+                const idManagerInit = await stepTwo(midLoginKey);
+                if (!idManagerInit) {
                     return;
                 }
+                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;
                 }
                 // 4) complete initialization of id manager
-                await idManager.setStorages(await this.storages.makeLocalFSForApp(MAILERID_APP_NAME), await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME));
+                await setupManagerStorage(await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME));
                 return idManager;
             };
         };
@@ -82,21 +89,12 @@ class Core {
             if (!completeStorageInit) {
                 return;
             }
-            const idManager = await id_manager_1.IdManager.initFromLocalStore(address, await this.storages.makeLocalFSForApp(MAILERID_APP_NAME), this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
-            if (idManager) {
-                const res = await completeStorageInit(idManager.getSigner);
-                await idManager.setStorages(undefined, await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME));
-                return (res ? idManager : undefined);
+            const idManager = await id_manager_1.IdManager.initFromCachedStore(address, await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME), this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            if (!idManager) {
+                return;
             }
-            return async (midLoginKey) => {
-                const idManager = await id_manager_1.IdManager.initInOneStepWithoutStore(address, midLoginKey, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
-                if (!idManager) {
-                    return;
-                }
-                const res = await completeStorageInit(idManager.getSigner);
-                await idManager.setStorages(await this.storages.makeLocalFSForApp(MAILERID_APP_NAME), await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME));
-                return (res ? idManager : undefined);
-            };
+            completeStorageInit(idManager.getSigner);
+            return idManager;
         };
         this.closeBroadcast = new rxjs_1.Subject();
         this.close$ = this.closeBroadcast.asObservable();
@@ -112,7 +110,7 @@ class Core {
         return core;
     }
     start() {
-        const signUp = new sign_up_1.SignUp(this.signUpUrl, this.cryptor.cryptor, () => this.makeNet(), this.appDirs.getUsersOnDisk, this.logger.logError);
+        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(),

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

@@ -6,8 +6,7 @@ import { LogError } from '../lib-client/logging/log-to-file';
 export declare type GenerateKey = (derivParams: ScryptGenParams) => Promise<Uint8Array>;
 export declare type StartInitWithoutCache = (address: string) => Promise<CompleteInitWithoutCache | undefined>;
 export declare type CompleteInitWithoutCache = (midLoginKey: GenerateKey, storageKey: GenerateKey) => Promise<IdManager | undefined>;
-export declare type InitWithCache = (address: string, storageKey: GenerateKey) => Promise<IdManager | undefined | InitTwoWithCache>;
-export declare type InitTwoWithCache = (midLoginKey: GenerateKey) => Promise<IdManager | undefined>;
+export declare type InitWithCache = (address: string, storageKey: GenerateKey) => Promise<IdManager | undefined>;
 declare type SignInService = web3n.startup.SignInService;
 export declare class SignIn {
     private cryptor;

package/build/core/sign-in.js

@@ -63,23 +63,14 @@ class SignIn {
             try {
                 const storeKeyProgressCB = makeKeyGenProgressCB(0, 99, progressCB);
                 const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
-                const res = await this.initWithCache(user, storeKeyGen);
-                if (!res) {
-                    return false;
-                }
-                if (typeof res === 'object') {
-                    this.doneBroadcast.next(res);
+                const idManager = await this.initWithCache(user, storeKeyGen);
+                if (idManager) {
+                    this.doneBroadcast.next(idManager);
                     return true;
                 }
-                progressCB(49);
-                const midKeyProgressCB = makeKeyGenProgressCB(50, 99, progressCB);
-                const midKeyGen = async (params) => (await (0, key_derivation_1.deriveMidKeyPair)(this.cryptor, pass, params, midKeyProgressCB)).skey;
-                const idManager = await res(midKeyGen);
-                if (!idManager) {
+                else {
                     return false;
                 }
-                this.doneBroadcast.next(idManager);
-                return true;
             }
             catch (err) {
                 throw await this.logAndWrap(err, 'Failing to start in a state with cache');

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

@@ -1,5 +1,6 @@
 import { NetClient } from '../lib-client/request-utils';
 import { JsonKey } from '../lib-common/jwkeys';
+import * as keyDeriv from '../lib-client/key-derivation';
 import { GetUsersOnDisk } from './app-files';
 import { Cryptor } from '../lib-client/cryptor/cryptor';
 import { LogError } from '../lib-client/logging/log-to-file';
@@ -40,5 +41,6 @@ export interface CreatedUser {
         labeled: JsonKey;
     };
     storeSKey: Uint8Array;
+    storeParams: keyDeriv.ScryptGenParams;
 }
 export {};

package/build/core/sign-up.js

@@ -96,7 +96,8 @@ class SignUp {
                     default: this.mid.defaultSKey,
                     labeled: this.mid.labeledSKey
                 },
-                storeSKey: this.store.skey
+                storeSKey: this.store.skey,
+                storeParams: this.store.params.kdParams
             });
             this.forgetKeys();
             return true;

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

@@ -2,6 +2,7 @@ import { GetSigner } from '../id-manager';
 import { GenerateKey } from '../sign-in';
 import { StorageGetter } from '../../lib-client/3nstorage/xsp-fs/common';
 import { ServiceLocator } from '../../lib-client/service-locator';
+import { ScryptGenParams } from '../../lib-client/key-derivation';
 import { AsyncSBoxCryptor } from 'xsp-files';
 import { StoragePathForUser } from '../app-files';
 import { LogError } from '../../lib-client/logging/log-to-file';
@@ -30,8 +31,9 @@ export declare class Storages implements FactoryOfFSs {
      * This is a storage getter for links and linking in synced storage.
      */
     private storageGetterForSyncedStorage;
-    startInitFromCache(user: string, keyGen: GenerateKey, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<((getSigner: GetSigner) => Promise<boolean>) | undefined>;
-    initFromRemote(user: string, getSigner: GetSigner, keyOrGen: GenerateKey | Uint8Array, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
+    startInitFromCache(user: string, keyGen: GenerateKey, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<((getSigner: GetSigner) => void) | undefined>;
+    initFromRemote(user: string, getSigner: GetSigner, generateKey: GenerateKey, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
+    initFreshForNewUser(user: string, getSigner: GetSigner, params: ScryptGenParams, key: Uint8Array, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
     makeSyncedFSForApp(appFolder: string): Promise<WritableFS>;
     makeLocalFSForApp(appFolder: string): Promise<WritableFS>;
     getUserFS(type: StorageType): Promise<FSItem>;