@pezkuwi/ui-keyring 3.16.6

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

@@ -0,0 +1,112 @@
+import { BehaviorSubject } from 'rxjs';
+import { obervableAll } from '../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;
+};
+export class KeyringOption {
+    #allSub = null;
+    optionsSubject = new 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 = 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: []
+        };
+    }
+}

package/build-tsc-esm/options/item.js

@@ -0,0 +1,13 @@
+import { isUndefined } from '@pezkuwi/util';
+export function createOptionItem(address, _name) {
+    const name = isUndefined(_name)
+        ? ((address.length > 15)
+            ? `${address.slice(0, 6)}…${address.slice(-6)}`
+            : address)
+        : _name;
+    return {
+        key: address,
+        name,
+        value: address
+    };
+}

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

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

package/build-tsc-esm/packageDetect.js

@@ -0,0 +1,4 @@
+import { packageInfo as settingsInfo } from '@pezkuwi/ui-settings/packageInfo';
+import { detectPackage } from '@pezkuwi/util';
+import { packageInfo } from './packageInfo.js';
+detectPackage(packageInfo, null, [settingsInfo]);

package/build-tsc-esm/packageInfo.js

@@ -0,0 +1 @@
+export const packageInfo = { name: '@pezkuwi/ui-keyring', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '3.16.6' };

package/build-tsc-esm/stores/Browser.js

@@ -0,0 +1,19 @@
+import store from 'store';
+export class BrowserStore {
+    all(fn) {
+        store.each((value, key) => {
+            fn(key, value);
+        });
+    }
+    get(key, fn) {
+        fn(store.get(key));
+    }
+    remove(key, fn) {
+        store.remove(key);
+        fn && fn();
+    }
+    set(key, value, fn) {
+        store.set(key, value);
+        fn && fn();
+    }
+}

package/build-tsc-esm/stores/File.js

@@ -0,0 +1,67 @@
+import { mkdirpSync } from 'mkdirp';
+import fs from 'node:fs';
+import path from 'node:path';
+export class FileStore {
+    #path;
+    constructor(path) {
+        if (!fs.existsSync(path)) {
+            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) {
+        fs
+            .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) {
+        fs.unlinkSync(this._getPath(key));
+        fn && fn();
+    }
+    set(key, value, fn) {
+        fs.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 path.join(this.#path, key);
+    }
+    _readKey(key) {
+        try {
+            return JSON.parse(fs.readFileSync(this._getPath(key)).toString('utf-8'));
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return undefined;
+    }
+}

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

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

package/build-tsc-esm/types.js

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

package/package.json

@@ -0,0 +1,41 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/ui/issues",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/ui/tree/master/packages/ui-keyring#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/ui-keyring",
+  "repository": {
+    "directory": "packages/ui-keyring",
+    "type": "git",
+    "url": "https://github.com/pezkuwichain/ui.git"
+  },
+  "sideEffects": [
+    "./packageDetect.js",
+    "./packageDetect.cjs"
+  ],
+  "type": "module",
+  "version": "3.16.6",
+  "main": "index.js",
+  "dependencies": {
+    "@pezkuwi/keyring": "^14.0.5",
+    "@pezkuwi/ui-settings": "3.16.6",
+    "@pezkuwi/util": "^14.0.5",
+    "@pezkuwi/util-crypto": "^14.0.5",
+    "mkdirp": "^3.0.1",
+    "rxjs": "^7.8.1",
+    "store": "^2.0.12",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/mkdirp": "^2.0.0",
+    "@types/store": "^2.0.5"
+  },
+  "peerDependencies": {
+    "@pezkuwi/keyring": "*",
+    "@pezkuwi/ui-settings": "*",
+    "@pezkuwi/util": "*"
+  }
+}

package/src/Base.ts

@@ -0,0 +1,156 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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';
+
+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: AddressSubject;
+
+  #addresses: AddressSubject;
+
+  #contracts: AddressSubject;
+
+  #isEthereum: boolean;
+
+  #keyring?: KeyringInstance;
+
+  protected _store: KeyringStore;
+
+  protected _genesisHash?: HexString | undefined;
+
+  protected _genesisHashAdd: HexString[] = [];
+
+  constructor () {
+    this.#accounts = accounts;
+    this.#addresses = addresses;
+    this.#contracts = contracts;
+    this.#isEthereum = false;
+    this._store = new BrowserStore();
+  }
+
+  public get accounts (): AddressSubject {
+    return this.#accounts;
+  }
+
+  public get addresses (): AddressSubject {
+    return this.#addresses;
+  }
+
+  public get contracts (): AddressSubject {
+    return this.#contracts;
+  }
+
+  public get isEthereum (): boolean {
+    return this.#isEthereum;
+  }
+
+  public get keyring (): KeyringInstance {
+    if (this.#keyring) {
+      return this.#keyring;
+    }
+
+    throw new Error('Keyring should be initialised via \'loadAll\' before use');
+  }
+
+  public get genesisHash (): HexString | undefined {
+    return this._genesisHash;
+  }
+
+  public get genesisHashes (): HexString[] {
+    return this._genesisHash
+      ? [this._genesisHash, ...this._genesisHashAdd]
+      : [...this._genesisHashAdd];
+  }
+
+  public decodeAddress = (key: string | Uint8Array, ignoreChecksum?: boolean, ss58Format?: Prefix): Uint8Array => {
+    return this.keyring.decodeAddress(key, ignoreChecksum, ss58Format);
+  };
+
+  public encodeAddress = (key: string | Uint8Array, ss58Format?: Prefix): string => {
+    return this.keyring.encodeAddress(key, ss58Format);
+  };
+
+  public getPair (address: string | Uint8Array): KeyringPair {
+    return this.keyring.getPair(address);
+  }
+
+  public getPairs (): KeyringPair[] {
+    return this.keyring.getPairs().filter((pair: KeyringPair): boolean =>
+      env.isDevelopment() || pair.meta.isTesting !== true
+    );
+  }
+
+  public isAvailable (_address: Uint8Array | string): boolean {
+    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];
+  }
+
+  public isPassValid (password: string): boolean {
+    return password.length > 0;
+  }
+
+  public setSS58Format (ss58Format?: Prefix): void {
+    if (this.#keyring && isNumber(ss58Format)) {
+      this.#keyring.setSS58Format(ss58Format);
+    }
+  }
+
+  public setDevMode (isDevelopment: boolean): void {
+    env.set(isDevelopment);
+  }
+
+  protected initKeyring (options: KeyringOptions): void {
+    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() as HexString
+        : options.genesisHash.toHex()
+    );
+    this._genesisHashAdd = options.genesisHashAdd || [];
+    this._store = options.store || this._store;
+
+    this.addAccountPairs();
+  }
+
+  protected addAccountPairs (): void {
+    this.keyring
+      .getPairs()
+      .forEach(({ address, meta }: KeyringPair): void => {
+        this.accounts.add(this._store, address, { address, meta });
+      });
+  }
+
+  protected addTimestamp (pair: KeyringPair): void {
+    if (!pair.meta.whenCreated) {
+      pair.setMeta({ whenCreated: Date.now() });
+    }
+  }
+}