@pezkuwi/ui-keyring 3.16.6

package/build/cjs/observable/genericSubject.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericSubject = genericSubject;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const item_js_1 = require("../options/item.js");
+const env_js_1 = require("./env.js");
+function callNext(current, subject, withTest) {
+    const isDevMode = env_js_1.env.isDevelopment();
+    const filtered = {};
+    Object.keys(current).forEach((key) => {
+        const { json: { meta: { isTesting = false } = {} } = {} } = current[key];
+        if (!withTest || isDevMode || isTesting !== true) {
+            filtered[key] = current[key];
+        }
+    });
+    subject.next(filtered);
+}
+function genericSubject(keyCreator, withTest = false) {
+    let current = {};
+    const subject = new rxjs_1.BehaviorSubject({});
+    const next = () => callNext(current, subject, withTest);
+    env_js_1.env.subject.subscribe(next);
+    return {
+        add: (store, address, json, type) => {
+            current = (0, util_1.objectCopy)(current);
+            current[address] = {
+                json: (0, util_1.objectSpread)({}, json, { address }),
+                option: (0, item_js_1.createOptionItem)(address, json.meta.name),
+                type
+            };
+            // we do not store dev or injected accounts (external/transient)
+            if (!json.meta.isInjected && (!json.meta.isTesting || env_js_1.env.isDevelopment())) {
+                store.set(keyCreator(address), json);
+            }
+            next();
+            return current[address];
+        },
+        remove: (store, address) => {
+            current = (0, util_1.objectCopy)(current);
+            delete current[address];
+            store.remove(keyCreator(address));
+            next();
+        },
+        subject
+    };
+}

package/build/cjs/observable/index.d.ts

@@ -0,0 +1,8 @@
+import type { SubjectInfo } from './types.js';
+interface Result {
+    accounts: SubjectInfo;
+    addresses: SubjectInfo;
+    contracts: SubjectInfo;
+}
+export declare const obervableAll: import("rxjs").Observable<Result>;
+export {};

package/build/cjs/observable/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.obervableAll = void 0;
+const rxjs_1 = require("rxjs");
+const accounts_js_1 = require("./accounts.js");
+const addresses_js_1 = require("./addresses.js");
+const contracts_js_1 = require("./contracts.js");
+exports.obervableAll = (0, rxjs_1.combineLatest)([
+    accounts_js_1.accounts.subject,
+    addresses_js_1.addresses.subject,
+    contracts_js_1.contracts.subject
+]).pipe((0, rxjs_1.map)(([accounts, addresses, contracts]) => ({
+    accounts,
+    addresses,
+    contracts
+})));

package/build/cjs/observable/types.d.ts

@@ -0,0 +1,15 @@
+import type { BehaviorSubject } from 'rxjs';
+import type { KeypairType } from '@pezkuwi/util-crypto/types';
+import type { KeyringSectionOption } from '../options/types.js';
+import type { KeyringJson, KeyringStore } from '../types.js';
+export interface SingleAddress {
+    json: KeyringJson;
+    option: KeyringSectionOption;
+    type?: KeypairType | undefined;
+}
+export type SubjectInfo = Record<string, SingleAddress>;
+export interface AddressSubject {
+    add: (store: KeyringStore, address: string, json: KeyringJson, type?: KeypairType) => SingleAddress;
+    remove: (store: KeyringStore, address: string) => void;
+    subject: BehaviorSubject<SubjectInfo>;
+}

package/build/cjs/observable/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/options/index.d.ts

@@ -0,0 +1,15 @@
+import type { KeyringStruct } from '../types.js';
+import type { KeyringOptionInstance, KeyringOptions, KeyringSectionOption } from './types.js';
+import { BehaviorSubject } from 'rxjs';
+export declare class KeyringOption implements KeyringOptionInstance {
+    #private;
+    readonly optionsSubject: BehaviorSubject<KeyringOptions>;
+    createOptionHeader(name: string): KeyringSectionOption;
+    init(keyring: KeyringStruct): void;
+    clear(): void;
+    private linkItems;
+    private addAccounts;
+    private addAddresses;
+    private addContracts;
+    private emptyOptions;
+}

package/build/cjs/options/index.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyringOption = void 0;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../observable/index.js");
+let hasCalledInitOptions = false;
+const sortByName = (a, b) => {
+    const valueA = a.option.name;
+    const valueB = b.option.name;
+    return valueA.localeCompare(valueB);
+};
+const sortByCreated = (a, b) => {
+    const valueA = a.json.meta.whenCreated || 0;
+    const valueB = b.json.meta.whenCreated || 0;
+    if (valueA < valueB) {
+        return 1;
+    }
+    if (valueA > valueB) {
+        return -1;
+    }
+    return 0;
+};
+class KeyringOption {
+    #allSub = null;
+    optionsSubject = new rxjs_1.BehaviorSubject(this.emptyOptions());
+    createOptionHeader(name) {
+        return {
+            key: `header-${name.toLowerCase()}`,
+            name,
+            value: null
+        };
+    }
+    init(keyring) {
+        if (hasCalledInitOptions) {
+            throw new Error('Unable to initialise options more than once');
+        }
+        this.#allSub = index_js_1.obervableAll.subscribe(() => {
+            const opts = this.emptyOptions();
+            this.addAccounts(keyring, opts);
+            this.addAddresses(keyring, opts);
+            this.addContracts(keyring, opts);
+            opts.address = this.linkItems({ Addresses: opts.address, Recent: opts.recent });
+            opts.account = this.linkItems({ Accounts: opts.account, Development: opts.testing });
+            opts.contract = this.linkItems({ Contracts: opts.contract });
+            opts.all = [].concat(opts.account, opts.address);
+            opts.allPlus = [].concat(opts.account, opts.address, opts.contract);
+            this.optionsSubject.next(opts);
+        });
+        hasCalledInitOptions = true;
+    }
+    clear() {
+        if (this.#allSub) {
+            this.#allSub.unsubscribe();
+        }
+    }
+    linkItems(items) {
+        return Object.keys(items).reduce((result, header) => {
+            const options = items[header];
+            return result.concat(options.length
+                ? [this.createOptionHeader(header)]
+                : [], options);
+        }, []);
+    }
+    addAccounts(keyring, options) {
+        const available = keyring.accounts.subject.getValue();
+        Object
+            .values(available)
+            .sort(sortByName)
+            .forEach(({ json: { meta: { isTesting = false } }, option }) => {
+            if (!isTesting) {
+                options.account.push(option);
+            }
+            else {
+                options.testing.push(option);
+            }
+        });
+    }
+    addAddresses(keyring, options) {
+        const available = keyring.addresses.subject.getValue();
+        Object
+            .values(available)
+            .filter(({ json }) => !!json.meta.isRecent)
+            .sort(sortByCreated)
+            .forEach(({ option }) => {
+            options.recent.push(option);
+        });
+        Object
+            .values(available)
+            .filter(({ json }) => !json.meta.isRecent)
+            .sort(sortByName)
+            .forEach(({ option }) => {
+            options.address.push(option);
+        });
+    }
+    addContracts(keyring, options) {
+        const available = keyring.contracts.subject.getValue();
+        Object
+            .values(available)
+            .sort(sortByName)
+            .forEach(({ option }) => {
+            options.contract.push(option);
+        });
+    }
+    emptyOptions() {
+        return {
+            account: [],
+            address: [],
+            all: [],
+            allPlus: [],
+            contract: [],
+            recent: [],
+            testing: []
+        };
+    }
+}
+exports.KeyringOption = KeyringOption;

package/build/cjs/options/item.d.ts

@@ -0,0 +1,2 @@
+import type { KeyringSectionOption } from './types.js';
+export declare function createOptionItem(address: string, _name?: string): KeyringSectionOption;

package/build/cjs/options/item.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOptionItem = createOptionItem;
+const util_1 = require("@pezkuwi/util");
+function createOptionItem(address, _name) {
+    const name = (0, util_1.isUndefined)(_name)
+        ? ((address.length > 15)
+            ? `${address.slice(0, 6)}…${address.slice(-6)}`
+            : address)
+        : _name;
+    return {
+        key: address,
+        name,
+        value: address
+    };
+}

package/build/cjs/options/types.d.ts

@@ -0,0 +1,15 @@
+import type { KeyringItemType, KeyringStruct } from '../types.js';
+export interface KeyringSectionOption {
+    key: string | null;
+    name: string;
+    value: string | null;
+}
+export type KeyringSectionOptions = KeyringSectionOption[];
+export type KeyringOptions = {
+    [type in KeyringItemType | 'all' | 'allPlus' | 'recent' | 'testing']: KeyringSectionOptions;
+};
+export type KeyringOption$Type = keyof KeyringOptions;
+export interface KeyringOptionInstance {
+    createOptionHeader: (name: string) => KeyringSectionOption;
+    init: (keyring: KeyringStruct) => void;
+}

package/build/cjs/options/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/build/cjs/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/build/cjs/packageDetect.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@pezkuwi/ui-settings/cjs/packageInfo");
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo]);

package/build/cjs/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/build/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@pezkuwi/ui-keyring', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '3.16.6' };

package/build/cjs/stores/Browser.d.ts

@@ -0,0 +1,7 @@
+import type { KeyringJson, KeyringStore } from '../types.js';
+export declare class BrowserStore implements KeyringStore {
+    all(fn: (key: string, value: KeyringJson) => void): void;
+    get(key: string, fn: (value: KeyringJson) => void): void;
+    remove(key: string, fn?: () => void): void;
+    set(key: string, value: KeyringJson, fn?: () => void): void;
+}

package/build/cjs/stores/Browser.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserStore = void 0;
+const tslib_1 = require("tslib");
+const store_1 = tslib_1.__importDefault(require("store"));
+class BrowserStore {
+    all(fn) {
+        store_1.default.each((value, key) => {
+            fn(key, value);
+        });
+    }
+    get(key, fn) {
+        fn(store_1.default.get(key));
+    }
+    remove(key, fn) {
+        store_1.default.remove(key);
+        fn && fn();
+    }
+    set(key, value, fn) {
+        store_1.default.set(key, value);
+        fn && fn();
+    }
+}
+exports.BrowserStore = BrowserStore;

package/build/cjs/stores/File.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringJson, KeyringStore } from '../types.js';
+export declare class FileStore implements KeyringStore {
+    #private;
+    constructor(path: string);
+    private validateKey;
+    all(fn: (key: string, value: KeyringJson) => void): void;
+    get(key: string, fn: (value: KeyringJson) => void): void;
+    remove(key: string, fn?: () => void): void;
+    set(key: string, value: KeyringJson, fn?: () => void): void;
+    private _getPath;
+    private _readKey;
+}

package/build/cjs/stores/File.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStore = void 0;
+const tslib_1 = require("tslib");
+const mkdirp_1 = require("mkdirp");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+class FileStore {
+    #path;
+    constructor(path) {
+        if (!node_fs_1.default.existsSync(path)) {
+            (0, mkdirp_1.mkdirpSync)(path);
+        }
+        this.#path = path;
+    }
+    validateKey(key) {
+        // Make sure the key has a .json extension
+        if (!key.endsWith('.json')) {
+            console.error('Non-JSON file requested: ', key);
+            return false;
+        }
+        // Remove '.json'
+        const keyWithoutExtension = key.slice(0, -5);
+        // Only allow alphanumeric characters, hyphens, and underscores in the base filename
+        const safeKeyRegex = /^[a-zA-Z0-9_-]+$/;
+        if (!safeKeyRegex.test(keyWithoutExtension)) {
+            console.error('Invalid key format detected: ', key);
+            return false;
+        }
+        return true;
+    }
+    all(fn) {
+        node_fs_1.default
+            .readdirSync(this.#path)
+            .filter((key) => !['.', '..', '.DS_Store'].includes(key))
+            .forEach((key) => {
+            const value = this._readKey(key);
+            value?.address && fn(key, value);
+        });
+    }
+    get(key, fn) {
+        const value = this._readKey(key);
+        if (!value?.address) {
+            throw new Error(`Invalid JSON found for ${key}`);
+        }
+        fn(value);
+    }
+    remove(key, fn) {
+        node_fs_1.default.unlinkSync(this._getPath(key));
+        fn && fn();
+    }
+    set(key, value, fn) {
+        node_fs_1.default.writeFileSync(this._getPath(key), Buffer.from(JSON.stringify(value), 'utf-8'));
+        fn && fn();
+    }
+    _getPath(key) {
+        if (!this.validateKey(key)) {
+            throw new Error('Invalid key format');
+        }
+        return node_path_1.default.join(this.#path, key);
+    }
+    _readKey(key) {
+        try {
+            return JSON.parse(node_fs_1.default.readFileSync(this._getPath(key)).toString('utf-8'));
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return undefined;
+    }
+}
+exports.FileStore = FileStore;

package/build/cjs/stores/index.d.ts

@@ -0,0 +1,2 @@
+export { BrowserStore } from './Browser.js';
+export { FileStore } from './File.js';

package/build/cjs/stores/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStore = exports.BrowserStore = void 0;
+var Browser_js_1 = require("./Browser.js");
+Object.defineProperty(exports, "BrowserStore", { enumerable: true, get: function () { return Browser_js_1.BrowserStore; } });
+var File_js_1 = require("./File.js");
+Object.defineProperty(exports, "FileStore", { enumerable: true, get: function () { return File_js_1.FileStore; } });

package/build/cjs/types.d.ts

@@ -0,0 +1,78 @@
+import type { KeyringInstance as BaseKeyringInstance, KeyringOptions as KeyringOptionsBase, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@pezkuwi/keyring/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { EncryptedJson } from '@pezkuwi/util-crypto/json/types';
+import type { KeypairType } from '@pezkuwi/util-crypto/types';
+import type { AddressSubject, SingleAddress } from './observable/types.js';
+export type ContractMeta = NonNullable<KeyringPair$Meta['contract']>;
+export type KeyringJson$Meta = KeyringPair$Meta;
+export interface KeyringJson {
+    address: string;
+    meta: KeyringJson$Meta;
+}
+export interface KeyringPairs$Json extends EncryptedJson {
+    accounts: KeyringJson[];
+}
+export interface KeyringStore {
+    all: (cb: (key: string, value: KeyringJson) => void) => void;
+    get: (key: string, cb: (value: KeyringJson) => void) => void;
+    remove: (key: string, cb?: () => void) => void;
+    set: (key: string, value: KeyringJson, cb?: () => void) => void;
+}
+export interface KeyringOptions extends KeyringOptionsBase {
+    filter?: (json: KeyringJson) => boolean;
+    genesisHash?: HexString | {
+        toHex: () => HexString;
+    };
+    genesisHashAdd?: HexString[];
+    isDevelopment?: boolean;
+    store?: KeyringStore;
+}
+export interface KeyringAddress {
+    readonly address: string;
+    readonly meta: KeyringJson$Meta;
+    readonly publicKey: Uint8Array;
+}
+export type KeyringAddressType = 'address' | 'contract';
+export type KeyringItemType = 'account' | KeyringAddressType;
+export interface CreateResult {
+    json: KeyringPair$Json;
+    pair: KeyringPair;
+}
+export interface KeyringStruct {
+    readonly accounts: AddressSubject;
+    readonly addresses: AddressSubject;
+    readonly contracts: AddressSubject;
+    readonly keyring: BaseKeyringInstance | undefined;
+    readonly genesisHash?: string | undefined;
+    addExternal: (publicKey: Uint8Array, meta?: KeyringPair$Meta) => CreateResult;
+    addPair: (pair: KeyringPair, password: string) => CreateResult;
+    addUri: (suri: string, password?: string, meta?: KeyringPair$Meta, type?: KeypairType) => CreateResult;
+    backupAccount: (pair: KeyringPair, password: string) => KeyringPair$Json;
+    backupAccounts: (addresses: string[], password: string) => Promise<KeyringPairs$Json>;
+    createFromUri(suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+    decodeAddress: (key: string | Uint8Array) => Uint8Array;
+    encodeAddress: (key: string | Uint8Array) => string;
+    encryptAccount: (pair: KeyringPair, password: string) => void;
+    forgetAccount: (address: string) => void;
+    forgetAddress: (address: string) => void;
+    forgetContract: (address: string) => void;
+    getAccount: (address: string | Uint8Array) => KeyringAddress | undefined;
+    getAccounts: () => KeyringAddress[];
+    getAddress: (address: string | Uint8Array, type: KeyringItemType | null) => KeyringAddress | undefined;
+    getAddresses: () => KeyringAddress[];
+    getContract: (address: string | Uint8Array) => KeyringAddress | undefined;
+    getContracts: (genesisHash?: string) => KeyringAddress[];
+    getPair: (address: string | Uint8Array) => KeyringPair;
+    getPairs: () => KeyringPair[];
+    isAvailable: (address: string | Uint8Array) => boolean;
+    isPassValid: (password: string) => boolean;
+    loadAll: (options: KeyringOptions) => void;
+    restoreAccount: (json: KeyringPair$Json, password: string) => KeyringPair;
+    restoreAccounts: (json: EncryptedJson, password: string) => void;
+    saveAccount: (pair: KeyringPair, password?: string) => KeyringPair$Json;
+    saveAccountMeta: (pair: KeyringPair, meta: KeyringPair$Meta) => void;
+    saveAddress: (address: string, meta: KeyringPair$Meta) => KeyringPair$Json;
+    saveContract: (address: string, meta: KeyringPair$Meta) => KeyringPair$Json;
+    saveRecent: (address: string) => SingleAddress;
+    setDevMode: (isDevelopment: boolean) => void;
+}

package/build/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/defaults.d.ts

@@ -0,0 +1,6 @@
+export declare function accountKey(address: string): string;
+export declare function addressKey(address: string): string;
+export declare function contractKey(address: string): string;
+export declare const accountRegex: RegExp;
+export declare const addressRegex: RegExp;
+export declare const contractRegex: RegExp;

package/build/defaults.js

@@ -0,0 +1,22 @@
+import { decodeAddress } from '@pezkuwi/keyring';
+import { u8aToHex } from '@pezkuwi/util';
+const ACCOUNT_PREFIX = 'account:';
+const ADDRESS_PREFIX = 'address:';
+const CONTRACT_PREFIX = 'contract:';
+function toHex(address) {
+    return u8aToHex(
+    // When saving pre-checksum changes, ensure that we can decode
+    decodeAddress(address, true));
+}
+export function accountKey(address) {
+    return `${ACCOUNT_PREFIX}${toHex(address)}`;
+}
+export function addressKey(address) {
+    return `${ADDRESS_PREFIX}${toHex(address)}`;
+}
+export function contractKey(address) {
+    return `${CONTRACT_PREFIX}${toHex(address)}`;
+}
+export const accountRegex = new RegExp(`^${ACCOUNT_PREFIX}0x[0-9a-f]*`, '');
+export const addressRegex = new RegExp(`^${ADDRESS_PREFIX}0x[0-9a-f]*`, '');
+export const contractRegex = new RegExp(`^${CONTRACT_PREFIX}0x[0-9a-f]*`, '');

package/build/index.d.ts

@@ -0,0 +1,4 @@
+import './packageDetect.js';
+import { keyring } from './bundle.js';
+export * from './bundle.js';
+export default keyring;

package/build/index.js

@@ -0,0 +1,4 @@
+import './packageDetect.js';
+import { keyring } from './bundle.js';
+export * from './bundle.js';
+export default keyring;

package/build/observable/accounts.d.ts

@@ -0,0 +1 @@
+export declare const accounts: import("./types.js").AddressSubject;

package/build/observable/accounts.js

@@ -0,0 +1,3 @@
+import { accountKey } from '../defaults.js';
+import { genericSubject } from './genericSubject.js';
+export const accounts = /*#__PURE__*/ genericSubject(accountKey, true);

package/build/observable/addresses.d.ts

@@ -0,0 +1 @@
+export declare const addresses: import("./types.js").AddressSubject;

package/build/observable/addresses.js

@@ -0,0 +1,3 @@
+import { addressKey } from '../defaults.js';
+import { genericSubject } from './genericSubject.js';
+export const addresses = /*#__PURE__*/ genericSubject(addressKey);

package/build/observable/contracts.d.ts

@@ -0,0 +1 @@
+export declare const contracts: import("./types.js").AddressSubject;

package/build/observable/contracts.js

@@ -0,0 +1,3 @@
+import { contractKey } from '../defaults.js';
+import { genericSubject } from './genericSubject.js';
+export const contracts = /*#__PURE__*/ genericSubject(contractKey);

package/build/observable/env.d.ts

@@ -0,0 +1,6 @@
+import { BehaviorSubject } from 'rxjs';
+export declare const env: {
+    isDevelopment: () => boolean;
+    set: (isDevelopment: boolean) => void;
+    subject: BehaviorSubject<boolean>;
+};

package/build/observable/env.js

@@ -0,0 +1,9 @@
+import { BehaviorSubject } from 'rxjs';
+const subject = new BehaviorSubject(false);
+export const env = {
+    isDevelopment: () => subject.getValue(),
+    set: (isDevelopment) => {
+        subject.next(isDevelopment);
+    },
+    subject
+};

package/build/observable/genericSubject.d.ts

@@ -0,0 +1,2 @@
+import type { AddressSubject } from './types.js';
+export declare function genericSubject(keyCreator: (address: string) => string, withTest?: boolean): AddressSubject;

package/build/observable/genericSubject.js

@@ -0,0 +1,44 @@
+import { BehaviorSubject } from 'rxjs';
+import { objectCopy, objectSpread } from '@pezkuwi/util';
+import { createOptionItem } from '../options/item.js';
+import { env } from './env.js';
+function callNext(current, subject, withTest) {
+    const isDevMode = env.isDevelopment();
+    const filtered = {};
+    Object.keys(current).forEach((key) => {
+        const { json: { meta: { isTesting = false } = {} } = {} } = current[key];
+        if (!withTest || isDevMode || isTesting !== true) {
+            filtered[key] = current[key];
+        }
+    });
+    subject.next(filtered);
+}
+export function genericSubject(keyCreator, withTest = false) {
+    let current = {};
+    const subject = new BehaviorSubject({});
+    const next = () => callNext(current, subject, withTest);
+    env.subject.subscribe(next);
+    return {
+        add: (store, address, json, type) => {
+            current = objectCopy(current);
+            current[address] = {
+                json: objectSpread({}, json, { address }),
+                option: createOptionItem(address, json.meta.name),
+                type
+            };
+            // we do not store dev or injected accounts (external/transient)
+            if (!json.meta.isInjected && (!json.meta.isTesting || env.isDevelopment())) {
+                store.set(keyCreator(address), json);
+            }
+            next();
+            return current[address];
+        },
+        remove: (store, address) => {
+            current = objectCopy(current);
+            delete current[address];
+            store.remove(keyCreator(address));
+            next();
+        },
+        subject
+    };
+}