@pezkuwi/ui-keyring 3.16.6

package/build/bundle.d.ts

@@ -0,0 +1,4 @@
+import { Keyring } from './Keyring.js';
+export { packageInfo } from './packageInfo.js';
+export declare const keyring: Keyring;
+export { Keyring };

package/build/bundle.js

@@ -0,0 +1,4 @@
+import { Keyring } from './Keyring.js';
+export { packageInfo } from './packageInfo.js';
+export const keyring = new Keyring();
+export { Keyring };

package/build/cjs/Base.d.ts

@@ -0,0 +1,30 @@
+import type { KeyringInstance, KeyringPair } from '@pezkuwi/keyring/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { Prefix } from '@pezkuwi/util-crypto/address/types';
+import type { AddressSubject } from './observable/types.js';
+import type { KeyringOptions, KeyringStore } from './types.js';
+export declare class Base {
+    #private;
+    protected _store: KeyringStore;
+    protected _genesisHash?: HexString | undefined;
+    protected _genesisHashAdd: HexString[];
+    constructor();
+    get accounts(): AddressSubject;
+    get addresses(): AddressSubject;
+    get contracts(): AddressSubject;
+    get isEthereum(): boolean;
+    get keyring(): KeyringInstance;
+    get genesisHash(): HexString | undefined;
+    get genesisHashes(): HexString[];
+    decodeAddress: (key: string | Uint8Array, ignoreChecksum?: boolean, ss58Format?: Prefix) => Uint8Array;
+    encodeAddress: (key: string | Uint8Array, ss58Format?: Prefix) => string;
+    getPair(address: string | Uint8Array): KeyringPair;
+    getPairs(): KeyringPair[];
+    isAvailable(_address: Uint8Array | string): boolean;
+    isPassValid(password: string): boolean;
+    setSS58Format(ss58Format?: Prefix): void;
+    setDevMode(isDevelopment: boolean): void;
+    protected initKeyring(options: KeyringOptions): void;
+    protected addAccountPairs(): void;
+    protected addTimestamp(pair: KeyringPair): void;
+}

package/build/cjs/Base.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+const keyring_1 = require("@pezkuwi/keyring");
+const util_1 = require("@pezkuwi/util");
+const accounts_js_1 = require("./observable/accounts.js");
+const addresses_js_1 = require("./observable/addresses.js");
+const contracts_js_1 = require("./observable/contracts.js");
+const env_js_1 = require("./observable/env.js");
+const Browser_js_1 = require("./stores/Browser.js"); // direct import (skip index with all)
+class Base {
+    #accounts;
+    #addresses;
+    #contracts;
+    #isEthereum;
+    #keyring;
+    _store;
+    _genesisHash;
+    _genesisHashAdd = [];
+    constructor() {
+        this.#accounts = accounts_js_1.accounts;
+        this.#addresses = addresses_js_1.addresses;
+        this.#contracts = contracts_js_1.contracts;
+        this.#isEthereum = false;
+        this._store = new Browser_js_1.BrowserStore();
+    }
+    get accounts() {
+        return this.#accounts;
+    }
+    get addresses() {
+        return this.#addresses;
+    }
+    get contracts() {
+        return this.#contracts;
+    }
+    get isEthereum() {
+        return this.#isEthereum;
+    }
+    get keyring() {
+        if (this.#keyring) {
+            return this.#keyring;
+        }
+        throw new Error('Keyring should be initialised via \'loadAll\' before use');
+    }
+    get genesisHash() {
+        return this._genesisHash;
+    }
+    get genesisHashes() {
+        return this._genesisHash
+            ? [this._genesisHash, ...this._genesisHashAdd]
+            : [...this._genesisHashAdd];
+    }
+    decodeAddress = (key, ignoreChecksum, ss58Format) => {
+        return this.keyring.decodeAddress(key, ignoreChecksum, ss58Format);
+    };
+    encodeAddress = (key, ss58Format) => {
+        return this.keyring.encodeAddress(key, ss58Format);
+    };
+    getPair(address) {
+        return this.keyring.getPair(address);
+    }
+    getPairs() {
+        return this.keyring.getPairs().filter((pair) => env_js_1.env.isDevelopment() || pair.meta.isTesting !== true);
+    }
+    isAvailable(_address) {
+        const accountsValue = this.accounts.subject.getValue();
+        const addressesValue = this.addresses.subject.getValue();
+        const contractsValue = this.contracts.subject.getValue();
+        const address = (0, util_1.isString)(_address)
+            ? _address
+            : this.encodeAddress(_address);
+        return !accountsValue[address] && !addressesValue[address] && !contractsValue[address];
+    }
+    isPassValid(password) {
+        return password.length > 0;
+    }
+    setSS58Format(ss58Format) {
+        if (this.#keyring && (0, util_1.isNumber)(ss58Format)) {
+            this.#keyring.setSS58Format(ss58Format);
+        }
+    }
+    setDevMode(isDevelopment) {
+        env_js_1.env.set(isDevelopment);
+    }
+    initKeyring(options) {
+        const keyring = (0, keyring_1.createTestKeyring)(options, true);
+        if ((0, util_1.isBoolean)(options.isDevelopment)) {
+            this.setDevMode(options.isDevelopment);
+        }
+        // set Ethereum state
+        this.#isEthereum = keyring.type === 'ethereum';
+        this.#keyring = keyring;
+        this._genesisHash = options.genesisHash && ((0, util_1.isString)(options.genesisHash)
+            ? options.genesisHash.toString()
+            : options.genesisHash.toHex());
+        this._genesisHashAdd = options.genesisHashAdd || [];
+        this._store = options.store || this._store;
+        this.addAccountPairs();
+    }
+    addAccountPairs() {
+        this.keyring
+            .getPairs()
+            .forEach(({ address, meta }) => {
+            this.accounts.add(this._store, address, { address, meta });
+        });
+    }
+    addTimestamp(pair) {
+        if (!pair.meta.whenCreated) {
+            pair.setMeta({ whenCreated: Date.now() });
+        }
+    }
+}
+exports.Base = Base;

package/build/cjs/Keyring.d.ts

@@ -0,0 +1,49 @@
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@pezkuwi/keyring/types';
+import type { BN } from '@pezkuwi/util';
+import type { EncryptedJson } from '@pezkuwi/util-crypto/json/types';
+import type { KeypairType } from '@pezkuwi/util-crypto/types';
+import type { SingleAddress } from './observable/types.js';
+import type { CreateResult, KeyringAddress, KeyringAddressType, KeyringItemType, KeyringJson$Meta, KeyringOptions, KeyringPairs$Json, KeyringStruct } from './types.js';
+import { KeyringOption } from './options/index.js';
+import { Base } from './Base.js';
+export declare class Keyring extends Base implements KeyringStruct {
+    #private;
+    readonly keyringOption: KeyringOption;
+    addExternal(address: string | Uint8Array, meta?: KeyringPair$Meta): CreateResult;
+    addHardware(address: string | Uint8Array, hardwareType: string, meta?: KeyringPair$Meta): CreateResult;
+    addMultisig(addresses: (string | Uint8Array)[], threshold: bigint | BN | number, 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>;
+    createFromJson(json: KeyringPair$Json, meta?: KeyringPair$Meta): KeyringPair;
+    createFromUri(suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+    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(): KeyringAddress[];
+    private rewriteKey;
+    private loadAccount;
+    private loadAddress;
+    private loadContract;
+    private loadInjected;
+    private allowGenesis;
+    loadAll(options: KeyringOptions, injected?: {
+        address: string;
+        meta: KeyringJson$Meta;
+        type?: KeypairType;
+    }[]): 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, type?: KeyringAddressType): KeyringPair$Json;
+    saveContract(address: string, meta: KeyringPair$Meta): KeyringPair$Json;
+    saveRecent(address: string): SingleAddress;
+}

package/build/cjs/Keyring.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Keyring = void 0;
+const keyring_1 = require("@pezkuwi/keyring");
+const ui_settings_1 = require("@pezkuwi/ui-settings");
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+const env_js_1 = require("./observable/env.js");
+const index_js_1 = require("./options/index.js");
+const Base_js_1 = require("./Base.js");
+const defaults_js_1 = require("./defaults.js");
+const RECENT_EXPIRY = 24 * 60 * 60;
+class Keyring extends Base_js_1.Base {
+    keyringOption = new index_js_1.KeyringOption();
+    #stores = {
+        account: () => this.accounts,
+        address: () => this.addresses,
+        contract: () => this.contracts
+    };
+    addExternal(address, meta = {}) {
+        const pair = this.keyring.addFromAddress(address, (0, util_1.objectSpread)({}, meta, { isExternal: true }), null, meta?.type);
+        return {
+            json: this.saveAccount(pair),
+            pair
+        };
+    }
+    addHardware(address, hardwareType, meta = {}) {
+        return this.addExternal(address, (0, util_1.objectSpread)({}, meta, { hardwareType, isHardware: true }));
+    }
+    addMultisig(addresses, threshold, meta = {}) {
+        let address = (0, util_crypto_1.createKeyMulti)(addresses, threshold);
+        // For Ethereum chains, the first 20 bytes of the hash indicates the actual address
+        // Testcases via creation and on-chain events:
+        // -  input: 0x7a1671a0224c8927b08f978027d586ab6868de0d31bb5bc956b625ced2ab18c4
+        // - output: 0x7a1671a0224c8927b08f978027d586ab6868de0d
+        if (this.isEthereum) {
+            address = address.slice(0, 20);
+        }
+        // we could use `sortAddresses`, but rather use internal encode/decode so we are 100%
+        const who = (0, util_1.u8aSorted)(addresses.map((who) => this.decodeAddress(who))).map((who) => this.encodeAddress(who));
+        return this.addExternal(address, (0, util_1.objectSpread)({}, meta, { isMultisig: true, threshold: (0, util_1.bnToBn)(threshold).toNumber(), who }));
+    }
+    addPair(pair, password) {
+        this.keyring.addPair(pair);
+        return {
+            json: this.saveAccount(pair, password),
+            pair
+        };
+    }
+    addUri(suri, password, meta = {}, type) {
+        const pair = this.keyring.addFromUri(suri, meta, type);
+        return {
+            json: this.saveAccount(pair, password),
+            pair
+        };
+    }
+    backupAccount(pair, password) {
+        if (!pair.isLocked) {
+            pair.lock();
+        }
+        pair.decodePkcs8(password);
+        return pair.toJson(password);
+    }
+    async backupAccounts(addresses, password) {
+        const accountPromises = addresses.map((address) => {
+            return new Promise((resolve) => {
+                this._store.get((0, defaults_js_1.accountKey)(address), resolve);
+            });
+        });
+        const accounts = await Promise.all(accountPromises);
+        return (0, util_1.objectSpread)({}, (0, util_crypto_1.jsonEncrypt)((0, util_1.stringToU8a)(JSON.stringify(accounts)), ['batch-pkcs8'], password), {
+            accounts: accounts.map((account) => ({
+                address: account.address,
+                meta: account.meta
+            }))
+        });
+    }
+    createFromJson(json, meta = {}) {
+        return this.keyring.createFromJson((0, util_1.objectSpread)({}, json, {
+            meta: (0, util_1.objectSpread)({}, json.meta, meta)
+        }));
+    }
+    createFromUri(suri, meta = {}, type) {
+        return this.keyring.createFromUri(suri, meta, type);
+    }
+    encryptAccount(pair, password) {
+        const json = pair.toJson(password);
+        json.meta.whenEdited = Date.now();
+        this.keyring.addFromJson(json);
+        this.accounts.add(this._store, pair.address, json, pair.type);
+    }
+    forgetAccount(address) {
+        this.keyring.removePair(address);
+        this.accounts.remove(this._store, address);
+    }
+    forgetAddress(address) {
+        this.addresses.remove(this._store, address);
+    }
+    forgetContract(address) {
+        this.contracts.remove(this._store, address);
+    }
+    getAccount(address) {
+        return this.getAddress(address, 'account');
+    }
+    getAccounts() {
+        const available = this.accounts.subject.getValue();
+        return Object
+            .keys(available)
+            .map((address) => this.getAddress(address, 'account'))
+            .filter((account) => !!account &&
+            (env_js_1.env.isDevelopment() ||
+                account.meta.isTesting !== true));
+    }
+    getAddress(_address, type = null) {
+        const address = (0, util_1.isString)(_address)
+            ? _address
+            : this.encodeAddress(_address);
+        const publicKey = this.decodeAddress(address);
+        const stores = type
+            ? [this.#stores[type]]
+            : Object.values(this.#stores);
+        const info = stores.reduce((lastInfo, store) => (store().subject.getValue()[address] || lastInfo), undefined);
+        return info && {
+            address,
+            meta: info.json.meta,
+            publicKey
+        };
+    }
+    getAddresses() {
+        const available = this.addresses.subject.getValue();
+        return Object
+            .keys(available)
+            .map((address) => this.getAddress(address))
+            .filter((account) => !!account);
+    }
+    getContract(address) {
+        return this.getAddress(address, 'contract');
+    }
+    getContracts() {
+        const available = this.contracts.subject.getValue();
+        return Object
+            .entries(available)
+            .filter(([, { json: { meta: { contract } } }]) => !!contract && contract.genesisHash === this.genesisHash)
+            .map(([address]) => this.getContract(address))
+            .filter((account) => !!account);
+    }
+    rewriteKey(json, key, hexAddr, creator) {
+        if (hexAddr.startsWith('0x')) {
+            return;
+        }
+        this._store.remove(key);
+        this._store.set(creator(hexAddr), json);
+    }
+    loadAccount(json, key) {
+        if (!json.meta.isTesting && json.encoded) {
+            const pair = this.keyring.addFromJson(json, true);
+            this.accounts.add(this._store, pair.address, json, pair.type);
+        }
+        const [, hexAddr] = key.split(':');
+        this.rewriteKey(json, key, hexAddr.trim(), defaults_js_1.accountKey);
+    }
+    loadAddress(json, key) {
+        const { isRecent, whenCreated = 0 } = json.meta;
+        if (isRecent && (Date.now() - whenCreated) > RECENT_EXPIRY) {
+            this._store.remove(key);
+            return;
+        }
+        // We assume anything hex that is not 32bytes (64 + 2 bytes hex) is an Ethereum-like address
+        // (this caters for both H160 addresses as well as full or compressed publicKeys) - in the case
+        // of both ecdsa and ethereum, we keep it as-is
+        const address = (0, util_1.isHex)(json.address) && json.address.length !== 66
+            ? json.address
+            : this.encodeAddress((0, util_1.isHex)(json.address)
+                ? (0, util_1.hexToU8a)(json.address)
+                // FIXME Just for the transition period (ignoreChecksum)
+                : this.decodeAddress(json.address, true));
+        const [, hexAddr] = key.split(':');
+        this.addresses.add(this._store, address, json);
+        this.rewriteKey(json, key, hexAddr, defaults_js_1.addressKey);
+    }
+    loadContract(json, key) {
+        const address = this.encodeAddress(this.decodeAddress(json.address));
+        const [, hexAddr] = key.split(':');
+        // move genesisHash to top-level (TODO Remove from contracts section?)
+        json.meta.genesisHash = json.meta.genesisHash || (json.meta.contract?.genesisHash);
+        this.contracts.add(this._store, address, json);
+        this.rewriteKey(json, key, hexAddr, defaults_js_1.contractKey);
+    }
+    loadInjected(address, meta, type) {
+        const json = {
+            address,
+            meta: (0, util_1.objectSpread)({}, meta, { isInjected: true })
+        };
+        const pair = this.keyring.addFromAddress(address, json.meta, null, type);
+        this.accounts.add(this._store, pair.address, json, pair.type);
+    }
+    allowGenesis(json) {
+        if (json?.meta && this.genesisHash) {
+            const hashes = Object.values(ui_settings_1.chains).find((hashes) => hashes.includes(this.genesisHash || '')) || [this.genesisHash];
+            if (json.meta.genesisHash) {
+                return hashes.includes(json.meta.genesisHash) || this.genesisHashes.includes(json.meta.genesisHash);
+            }
+            else if (json.meta.contract) {
+                return hashes.includes(json.meta.contract.genesisHash);
+            }
+        }
+        return true;
+    }
+    loadAll(options, injected = []) {
+        super.initKeyring(options);
+        this._store.all((key, json) => {
+            if (!(0, util_1.isFunction)(options.filter) || options.filter(json)) {
+                try {
+                    if (this.allowGenesis(json)) {
+                        if (defaults_js_1.accountRegex.test(key)) {
+                            this.loadAccount(json, key);
+                        }
+                        else if (defaults_js_1.addressRegex.test(key)) {
+                            this.loadAddress(json, key);
+                        }
+                        else if (defaults_js_1.contractRegex.test(key)) {
+                            this.loadContract(json, key);
+                        }
+                    }
+                }
+                catch {
+                    console.warn(`Keyring: Unable to load ${key}:${(0, util_1.stringify)(json)}`);
+                }
+            }
+        });
+        injected.forEach((account) => {
+            if (this.allowGenesis(account)) {
+                try {
+                    this.loadInjected(account.address, account.meta, account.type);
+                }
+                catch {
+                    console.warn(`Keyring: Unable to inject ${(0, util_1.stringify)(account)}`);
+                }
+            }
+        });
+        this.keyringOption.init(this);
+    }
+    restoreAccount(json, password) {
+        const cryptoType = Array.isArray(json.encoding.content) ? json.encoding.content[1] : 'ed25519';
+        const encType = Array.isArray(json.encoding.type) ? json.encoding.type : [json.encoding.type];
+        const pair = (0, keyring_1.createPair)({ toSS58: this.encodeAddress, type: cryptoType }, { publicKey: this.decodeAddress(json.address, true) }, json.meta, (0, util_1.isHex)(json.encoded) ? (0, util_1.hexToU8a)(json.encoded) : (0, util_crypto_1.base64Decode)(json.encoded), encType);
+        // unlock, save account and then lock (locking cleans secretKey, so needs to be last)
+        pair.decodePkcs8(password);
+        this.addPair(pair, password);
+        pair.lock();
+        return pair;
+    }
+    restoreAccounts(json, password) {
+        const accounts = JSON.parse((0, util_1.u8aToString)((0, util_crypto_1.jsonDecrypt)(json, password)));
+        accounts.forEach((account) => {
+            this.loadAccount(account, (0, defaults_js_1.accountKey)(account.address));
+        });
+    }
+    saveAccount(pair, password) {
+        this.addTimestamp(pair);
+        const json = pair.toJson(password);
+        this.keyring.addFromJson(json);
+        this.accounts.add(this._store, pair.address, json, pair.type);
+        return json;
+    }
+    saveAccountMeta(pair, meta) {
+        const address = pair.address;
+        this._store.get((0, defaults_js_1.accountKey)(address), (json) => {
+            pair.setMeta(meta);
+            json.meta = pair.meta;
+            this.accounts.add(this._store, address, json, pair.type);
+        });
+    }
+    saveAddress(address, meta, type = 'address') {
+        const available = this.addresses.subject.getValue();
+        const json = available[address]?.json || {
+            address,
+            meta: {
+                isRecent: undefined,
+                whenCreated: Date.now()
+            }
+        };
+        Object.keys(meta).forEach((key) => {
+            json.meta[key] = meta[key];
+        });
+        delete json.meta.isRecent;
+        this.#stores[type]().add(this._store, address, json);
+        return json;
+    }
+    saveContract(address, meta) {
+        return this.saveAddress(address, meta, 'contract');
+    }
+    saveRecent(address) {
+        const available = this.addresses.subject.getValue();
+        if (!available[address]) {
+            this.addresses.add(this._store, address, {
+                address,
+                meta: {
+                    genesisHash: this.genesisHash,
+                    isRecent: true,
+                    whenCreated: Date.now()
+                }
+            });
+        }
+        return this.addresses.subject.getValue()[address];
+    }
+}
+exports.Keyring = Keyring;

package/build/cjs/bundle.d.ts

@@ -0,0 +1,4 @@
+import { Keyring } from './Keyring.js';
+export { packageInfo } from './packageInfo.js';
+export declare const keyring: Keyring;
+export { Keyring };

package/build/cjs/bundle.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Keyring = exports.keyring = exports.packageInfo = void 0;
+const Keyring_js_1 = require("./Keyring.js");
+Object.defineProperty(exports, "Keyring", { enumerable: true, get: function () { return Keyring_js_1.Keyring; } });
+var packageInfo_js_1 = require("./packageInfo.js");
+Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+exports.keyring = new Keyring_js_1.Keyring();

package/build/cjs/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/cjs/defaults.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractRegex = exports.addressRegex = exports.accountRegex = void 0;
+exports.accountKey = accountKey;
+exports.addressKey = addressKey;
+exports.contractKey = contractKey;
+const keyring_1 = require("@pezkuwi/keyring");
+const util_1 = require("@pezkuwi/util");
+const ACCOUNT_PREFIX = 'account:';
+const ADDRESS_PREFIX = 'address:';
+const CONTRACT_PREFIX = 'contract:';
+function toHex(address) {
+    return (0, util_1.u8aToHex)(
+    // When saving pre-checksum changes, ensure that we can decode
+    (0, keyring_1.decodeAddress)(address, true));
+}
+function accountKey(address) {
+    return `${ACCOUNT_PREFIX}${toHex(address)}`;
+}
+function addressKey(address) {
+    return `${ADDRESS_PREFIX}${toHex(address)}`;
+}
+function contractKey(address) {
+    return `${CONTRACT_PREFIX}${toHex(address)}`;
+}
+exports.accountRegex = new RegExp(`^${ACCOUNT_PREFIX}0x[0-9a-f]*`, '');
+exports.addressRegex = new RegExp(`^${ADDRESS_PREFIX}0x[0-9a-f]*`, '');
+exports.contractRegex = new RegExp(`^${CONTRACT_PREFIX}0x[0-9a-f]*`, '');

package/build/cjs/index.d.ts

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

package/build/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("./packageDetect.js");
+const bundle_js_1 = require("./bundle.js");
+tslib_1.__exportStar(require("./bundle.js"), exports);
+exports.default = bundle_js_1.keyring;

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

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

package/build/cjs/observable/accounts.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accounts = void 0;
+const defaults_js_1 = require("../defaults.js");
+const genericSubject_js_1 = require("./genericSubject.js");
+exports.accounts = (0, genericSubject_js_1.genericSubject)(defaults_js_1.accountKey, true);

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

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

package/build/cjs/observable/addresses.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addresses = void 0;
+const defaults_js_1 = require("../defaults.js");
+const genericSubject_js_1 = require("./genericSubject.js");
+exports.addresses = (0, genericSubject_js_1.genericSubject)(defaults_js_1.addressKey);

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

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

package/build/cjs/observable/contracts.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contracts = void 0;
+const defaults_js_1 = require("../defaults.js");
+const genericSubject_js_1 = require("./genericSubject.js");
+exports.contracts = (0, genericSubject_js_1.genericSubject)(defaults_js_1.contractKey);

package/build/cjs/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/cjs/observable/env.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+const rxjs_1 = require("rxjs");
+const subject = new rxjs_1.BehaviorSubject(false);
+exports.env = {
+    isDevelopment: () => subject.getValue(),
+    set: (isDevelopment) => {
+        subject.next(isDevelopment);
+    },
+    subject
+};

package/build/cjs/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;