@pezkuwi/ui-keyring 3.16.6

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

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

package/build-tsc-esm/Base.js

@@ -0,0 +1,109 @@
+import { createTestKeyring } from '@pezkuwi/keyring';
+import { isBoolean, isNumber, isString } from '@pezkuwi/util';
+import { accounts } from './observable/accounts.js';
+import { addresses } from './observable/addresses.js';
+import { contracts } from './observable/contracts.js';
+import { env } from './observable/env.js';
+import { BrowserStore } from './stores/Browser.js'; // direct import (skip index with all)
+export class Base {
+    #accounts;
+    #addresses;
+    #contracts;
+    #isEthereum;
+    #keyring;
+    _store;
+    _genesisHash;
+    _genesisHashAdd = [];
+    constructor() {
+        this.#accounts = accounts;
+        this.#addresses = addresses;
+        this.#contracts = contracts;
+        this.#isEthereum = false;
+        this._store = new 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.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 = isString(_address)
+            ? _address
+            : this.encodeAddress(_address);
+        return !accountsValue[address] && !addressesValue[address] && !contractsValue[address];
+    }
+    isPassValid(password) {
+        return password.length > 0;
+    }
+    setSS58Format(ss58Format) {
+        if (this.#keyring && isNumber(ss58Format)) {
+            this.#keyring.setSS58Format(ss58Format);
+        }
+    }
+    setDevMode(isDevelopment) {
+        env.set(isDevelopment);
+    }
+    initKeyring(options) {
+        const keyring = createTestKeyring(options, true);
+        if (isBoolean(options.isDevelopment)) {
+            this.setDevMode(options.isDevelopment);
+        }
+        // set Ethereum state
+        this.#isEthereum = keyring.type === 'ethereum';
+        this.#keyring = keyring;
+        this._genesisHash = options.genesisHash && (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() });
+        }
+    }
+}

package/build-tsc-esm/Keyring.js

@@ -0,0 +1,304 @@
+import { createPair } from '@pezkuwi/keyring';
+import { chains } from '@pezkuwi/ui-settings';
+import { bnToBn, hexToU8a, isFunction, isHex, isString, objectSpread, stringify, stringToU8a, u8aSorted, u8aToString } from '@pezkuwi/util';
+import { base64Decode, createKeyMulti, jsonDecrypt, jsonEncrypt } from '@pezkuwi/util-crypto';
+import { env } from './observable/env.js';
+import { KeyringOption } from './options/index.js';
+import { Base } from './Base.js';
+import { accountKey, accountRegex, addressKey, addressRegex, contractKey, contractRegex } from './defaults.js';
+const RECENT_EXPIRY = 24 * 60 * 60;
+export class Keyring extends Base {
+    keyringOption = new KeyringOption();
+    #stores = {
+        account: () => this.accounts,
+        address: () => this.addresses,
+        contract: () => this.contracts
+    };
+    addExternal(address, meta = {}) {
+        const pair = this.keyring.addFromAddress(address, objectSpread({}, meta, { isExternal: true }), null, meta?.type);
+        return {
+            json: this.saveAccount(pair),
+            pair
+        };
+    }
+    addHardware(address, hardwareType, meta = {}) {
+        return this.addExternal(address, objectSpread({}, meta, { hardwareType, isHardware: true }));
+    }
+    addMultisig(addresses, threshold, meta = {}) {
+        let address = 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 = u8aSorted(addresses.map((who) => this.decodeAddress(who))).map((who) => this.encodeAddress(who));
+        return this.addExternal(address, objectSpread({}, meta, { isMultisig: true, threshold: 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(accountKey(address), resolve);
+            });
+        });
+        const accounts = await Promise.all(accountPromises);
+        return objectSpread({}, jsonEncrypt(stringToU8a(JSON.stringify(accounts)), ['batch-pkcs8'], password), {
+            accounts: accounts.map((account) => ({
+                address: account.address,
+                meta: account.meta
+            }))
+        });
+    }
+    createFromJson(json, meta = {}) {
+        return this.keyring.createFromJson(objectSpread({}, json, {
+            meta: 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.isDevelopment() ||
+                account.meta.isTesting !== true));
+    }
+    getAddress(_address, type = null) {
+        const address = 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(), 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 = isHex(json.address) && json.address.length !== 66
+            ? json.address
+            : this.encodeAddress(isHex(json.address)
+                ? 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, 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, contractKey);
+    }
+    loadInjected(address, meta, type) {
+        const json = {
+            address,
+            meta: 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(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 (!isFunction(options.filter) || options.filter(json)) {
+                try {
+                    if (this.allowGenesis(json)) {
+                        if (accountRegex.test(key)) {
+                            this.loadAccount(json, key);
+                        }
+                        else if (addressRegex.test(key)) {
+                            this.loadAddress(json, key);
+                        }
+                        else if (contractRegex.test(key)) {
+                            this.loadContract(json, key);
+                        }
+                    }
+                }
+                catch {
+                    console.warn(`Keyring: Unable to load ${key}:${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 ${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 = createPair({ toSS58: this.encodeAddress, type: cryptoType }, { publicKey: this.decodeAddress(json.address, true) }, json.meta, isHex(json.encoded) ? hexToU8a(json.encoded) : 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(u8aToString(jsonDecrypt(json, password)));
+        accounts.forEach((account) => {
+            this.loadAccount(account, 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(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];
+    }
+}

package/build-tsc-esm/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-tsc-esm/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-tsc-esm/index.js

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

package/build-tsc-esm/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-tsc-esm/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-tsc-esm/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-tsc-esm/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-tsc-esm/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
+    };
+}

package/build-tsc-esm/observable/index.js

@@ -0,0 +1,13 @@
+import { combineLatest, map } from 'rxjs';
+import { accounts } from './accounts.js';
+import { addresses } from './addresses.js';
+import { contracts } from './contracts.js';
+export const obervableAll = /*#__PURE__*/ combineLatest([
+    accounts.subject,
+    addresses.subject,
+    contracts.subject
+]).pipe(map(([accounts, addresses, contracts]) => ({
+    accounts,
+    addresses,
+    contracts
+})));

package/build-tsc-esm/observable/types.js

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