@pezkuwi/ui-keyring 3.16.6

package/src/Keyring.ts

@@ -0,0 +1,420 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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 { AddressSubject, SingleAddress } from './observable/types.js';
+import type { CreateResult, KeyringAddress, KeyringAddressType, KeyringItemType, KeyringJson, KeyringJson$Meta, KeyringOptions, KeyringPairs$Json, KeyringStruct } from './types.js';
+
+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;
+
+// No accounts (or test accounts) should be loaded until after the chain determination.
+// Chain determination occurs outside of Keyring. Loading `keyring.loadAll({ type: 'ed25519' | 'sr25519' })` is triggered
+// from the API after the chain is received
+export class Keyring extends Base implements KeyringStruct {
+  public readonly keyringOption = new KeyringOption();
+
+  #stores = {
+    account: (): AddressSubject => this.accounts,
+    address: (): AddressSubject => this.addresses,
+    contract: (): AddressSubject => this.contracts
+  };
+
+  public addExternal (address: string | Uint8Array, meta: KeyringPair$Meta = {}): CreateResult {
+    const pair = this.keyring.addFromAddress(address, objectSpread<KeyringJson$Meta>({}, meta, { isExternal: true }), null, meta?.type);
+
+    return {
+      json: this.saveAccount(pair),
+      pair
+    };
+  }
+
+  public addHardware (address: string | Uint8Array, hardwareType: string, meta: KeyringPair$Meta = {}): CreateResult {
+    return this.addExternal(address, objectSpread<KeyringPair$Meta>({}, meta, { hardwareType, isHardware: true }));
+  }
+
+  public addMultisig (addresses: (string | Uint8Array)[], threshold: bigint | BN | number, meta: KeyringPair$Meta = {}): CreateResult {
+    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<KeyringPair$Meta>({}, meta, { isMultisig: true, threshold: bnToBn(threshold).toNumber(), who }));
+  }
+
+  public addPair (pair: KeyringPair, password: string): CreateResult {
+    this.keyring.addPair(pair);
+
+    return {
+      json: this.saveAccount(pair, password),
+      pair
+    };
+  }
+
+  public addUri (suri: string, password?: string, meta: KeyringPair$Meta = {}, type?: KeypairType): CreateResult {
+    const pair = this.keyring.addFromUri(suri, meta, type);
+
+    return {
+      json: this.saveAccount(pair, password),
+      pair
+    };
+  }
+
+  public backupAccount (pair: KeyringPair, password: string): KeyringPair$Json {
+    if (!pair.isLocked) {
+      pair.lock();
+    }
+
+    pair.decodePkcs8(password);
+
+    return pair.toJson(password);
+  }
+
+  public async backupAccounts (addresses: string[], password: string): Promise<KeyringPairs$Json> {
+    const accountPromises = addresses.map((address) => {
+      return new Promise<KeyringJson>((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
+      }))
+    });
+  }
+
+  public createFromJson (json: KeyringPair$Json, meta: KeyringPair$Meta = {}): KeyringPair {
+    return this.keyring.createFromJson(
+      objectSpread({}, json, {
+        meta: objectSpread({}, json.meta, meta)
+      })
+    );
+  }
+
+  public createFromUri (suri: string, meta: KeyringPair$Meta = {}, type?: KeypairType): KeyringPair {
+    return this.keyring.createFromUri(suri, meta, type);
+  }
+
+  public encryptAccount (pair: KeyringPair, password: string): void {
+    const json = pair.toJson(password);
+
+    json.meta.whenEdited = Date.now();
+
+    this.keyring.addFromJson(json);
+    this.accounts.add(this._store, pair.address, json, pair.type);
+  }
+
+  public forgetAccount (address: string): void {
+    this.keyring.removePair(address);
+    this.accounts.remove(this._store, address);
+  }
+
+  public forgetAddress (address: string): void {
+    this.addresses.remove(this._store, address);
+  }
+
+  public forgetContract (address: string): void {
+    this.contracts.remove(this._store, address);
+  }
+
+  public getAccount (address: string | Uint8Array): KeyringAddress | undefined {
+    return this.getAddress(address, 'account');
+  }
+
+  public getAccounts (): KeyringAddress[] {
+    const available = this.accounts.subject.getValue();
+
+    return Object
+      .keys(available)
+      .map((address) => this.getAddress(address, 'account'))
+      .filter((account): account is KeyringAddress =>
+        !!account &&
+        (
+          env.isDevelopment() ||
+          account.meta.isTesting !== true
+        )
+      );
+  }
+
+  public getAddress (_address: string | Uint8Array, type: KeyringItemType | null = null): KeyringAddress | undefined {
+    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<SingleAddress | undefined>((lastInfo, store): SingleAddress | undefined =>
+      (store().subject.getValue()[address] || lastInfo), undefined);
+
+    return info && {
+      address,
+      meta: info.json.meta,
+      publicKey
+    };
+  }
+
+  public getAddresses (): KeyringAddress[] {
+    const available = this.addresses.subject.getValue();
+
+    return Object
+      .keys(available)
+      .map((address) => this.getAddress(address))
+      .filter((account): account is KeyringAddress => !!account);
+  }
+
+  public getContract (address: string | Uint8Array): KeyringAddress | undefined {
+    return this.getAddress(address, 'contract');
+  }
+
+  public getContracts (): KeyringAddress[] {
+    const available = this.contracts.subject.getValue();
+
+    return Object
+      .entries(available)
+      .filter(([, { json: { meta: { contract } } }]): boolean =>
+        !!contract && contract.genesisHash === this.genesisHash
+      )
+      .map(([address]) => this.getContract(address))
+      .filter((account): account is KeyringAddress => !!account);
+  }
+
+  private rewriteKey (json: KeyringJson, key: string, hexAddr: string, creator: (addr: string) => string): void {
+    if (hexAddr.startsWith('0x')) {
+      return;
+    }
+
+    this._store.remove(key);
+    this._store.set(creator(hexAddr), json);
+  }
+
+  private loadAccount (json: KeyringJson, key: string): void {
+    if (!json.meta.isTesting && (json as KeyringPair$Json).encoded) {
+      const pair = this.keyring.addFromJson(json as KeyringPair$Json, true);
+
+      this.accounts.add(this._store, pair.address, json, pair.type);
+    }
+
+    const [, hexAddr] = key.split(':');
+
+    this.rewriteKey(json, key, hexAddr.trim(), accountKey);
+  }
+
+  private loadAddress (json: KeyringJson, key: string): void {
+    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);
+  }
+
+  private loadContract (json: KeyringJson, key: string): void {
+    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);
+  }
+
+  private loadInjected (address: string, meta: KeyringJson$Meta, type?: KeypairType): void {
+    const json = {
+      address,
+      meta: objectSpread<KeyringJson$Meta>({}, meta, { isInjected: true })
+    };
+    const pair = this.keyring.addFromAddress(address, json.meta, null, type);
+
+    this.accounts.add(this._store, pair.address, json, pair.type);
+  }
+
+  private allowGenesis (json?: KeyringJson | { meta: KeyringJson$Meta } | null): boolean {
+    if (json?.meta && this.genesisHash) {
+      const hashes: (string | null | undefined)[] = Object.values(chains).find((hashes): boolean =>
+        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;
+  }
+
+  public loadAll (options: KeyringOptions, injected: { address: string; meta: KeyringJson$Meta, type?: KeypairType }[] = []): void {
+    super.initKeyring(options);
+
+    this._store.all((key: string, json: KeyringJson): void => {
+      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): void => {
+      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);
+  }
+
+  public restoreAccount (json: KeyringPair$Json, password: string): KeyringPair {
+    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 as KeypairType },
+      { 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;
+  }
+
+  public restoreAccounts (json: EncryptedJson, password: string): void {
+    const accounts: KeyringJson[] = JSON.parse(u8aToString(jsonDecrypt(json, password))) as KeyringJson[];
+
+    accounts.forEach((account) => {
+      this.loadAccount(account, accountKey(account.address));
+    });
+  }
+
+  public saveAccount (pair: KeyringPair, password?: string): KeyringPair$Json {
+    this.addTimestamp(pair);
+
+    const json = pair.toJson(password);
+
+    this.keyring.addFromJson(json);
+    this.accounts.add(this._store, pair.address, json, pair.type);
+
+    return json;
+  }
+
+  public saveAccountMeta (pair: KeyringPair, meta: KeyringPair$Meta): void {
+    const address = pair.address;
+
+    this._store.get(accountKey(address), (json: KeyringJson): void => {
+      pair.setMeta(meta);
+      json.meta = pair.meta;
+
+      this.accounts.add(this._store, address, json, pair.type);
+    });
+  }
+
+  public saveAddress (address: string, meta: KeyringPair$Meta, type: KeyringAddressType = 'address'): KeyringPair$Json {
+    const available = this.addresses.subject.getValue();
+
+    const json = available[address]?.json || {
+      address,
+      meta: {
+        isRecent: undefined,
+        whenCreated: Date.now()
+      }
+    };
+
+    Object.keys(meta).forEach((key): void => {
+      json.meta[key] = meta[key];
+    });
+
+    delete json.meta.isRecent;
+
+    this.#stores[type]().add(this._store, address, json);
+
+    return json as KeyringPair$Json;
+  }
+
+  public saveContract (address: string, meta: KeyringPair$Meta): KeyringPair$Json {
+    return this.saveAddress(address, meta, 'contract');
+  }
+
+  public saveRecent (address: string): SingleAddress {
+    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/src/bundle.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Keyring } from './Keyring.js';
+
+export { packageInfo } from './packageInfo.js';
+
+export const keyring = new Keyring();
+
+export { Keyring };

package/src/defaults.ts

@@ -0,0 +1,34 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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: string): string {
+  return u8aToHex(
+    // When saving pre-checksum changes, ensure that we can decode
+    decodeAddress(address, true)
+  );
+}
+
+export function accountKey (address: string): string {
+  return `${ACCOUNT_PREFIX}${toHex(address)}`;
+}
+
+export function addressKey (address: string): string {
+  return `${ADDRESS_PREFIX}${toHex(address)}`;
+}
+
+export function contractKey (address: string): string {
+  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/src/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './packageDetect.js';
+
+import { keyring } from './bundle.js';
+
+export * from './bundle.js';
+
+export default keyring;

package/src/json.d.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Be able to import json in TS
+// https://stackoverflow.com/questions/49996456/importing-json-file-in-typescript
+declare module '*.json' {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const value: any;
+
+  export default value;
+}

package/src/observable/accounts.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { accountKey } from '../defaults.js';
+import { genericSubject } from './genericSubject.js';
+
+export const accounts = /*#__PURE__*/ genericSubject(accountKey, true);

package/src/observable/addresses.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { addressKey } from '../defaults.js';
+import { genericSubject } from './genericSubject.js';
+
+export const addresses = /*#__PURE__*/ genericSubject(addressKey);

package/src/observable/contracts.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { contractKey } from '../defaults.js';
+import { genericSubject } from './genericSubject.js';
+
+export const contracts = /*#__PURE__*/ genericSubject(contractKey);

package/src/observable/env.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BehaviorSubject } from 'rxjs';
+
+const subject = new BehaviorSubject(false);
+
+export const env = {
+  isDevelopment: (): boolean =>
+    subject.getValue(),
+  set: (isDevelopment: boolean): void => {
+    subject.next(isDevelopment);
+  },
+  subject
+};

package/src/observable/genericSubject.ts

@@ -0,0 +1,66 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { KeypairType } from '@pezkuwi/util-crypto/types';
+import type { KeyringJson, KeyringStore } from '../types.js';
+import type { AddressSubject, SingleAddress, SubjectInfo } from './types.js';
+
+import { BehaviorSubject } from 'rxjs';
+
+import { objectCopy, objectSpread } from '@pezkuwi/util';
+
+import { createOptionItem } from '../options/item.js';
+import { env } from './env.js';
+
+function callNext (current: SubjectInfo, subject: BehaviorSubject<SubjectInfo>, withTest: boolean): void {
+  const isDevMode = env.isDevelopment();
+  const filtered: SubjectInfo = {};
+
+  Object.keys(current).forEach((key): void => {
+    const { json: { meta: { isTesting = false } = {} } = {} } = current[key];
+
+    if (!withTest || isDevMode || isTesting !== true) {
+      filtered[key] = current[key];
+    }
+  });
+
+  subject.next(filtered);
+}
+
+export function genericSubject (keyCreator: (address: string) => string, withTest = false): AddressSubject {
+  let current: SubjectInfo = {};
+  const subject = new BehaviorSubject({});
+  const next = (): void => callNext(current, subject, withTest);
+
+  env.subject.subscribe(next);
+
+  return {
+    add: (store: KeyringStore, address: string, json: KeyringJson, type?: KeypairType): SingleAddress => {
+      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: KeyringStore, address: string): void => {
+      current = objectCopy(current);
+
+      delete current[address];
+
+      store.remove(keyCreator(address));
+      next();
+    },
+    subject
+  };
+}

package/src/observable/index.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { SubjectInfo } from './types.js';
+
+import { combineLatest, map } from 'rxjs';
+
+import { accounts } from './accounts.js';
+import { addresses } from './addresses.js';
+import { contracts } from './contracts.js';
+
+interface Result {
+  accounts: SubjectInfo;
+  addresses: SubjectInfo;
+  contracts: SubjectInfo;
+}
+
+export const obervableAll = /*#__PURE__*/ combineLatest([
+  accounts.subject,
+  addresses.subject,
+  contracts.subject
+]).pipe(
+  map(([accounts, addresses, contracts]): Result => ({
+    accounts,
+    addresses,
+    contracts
+  }))
+);

package/src/observable/types.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2025 @pezkuwi/ui-keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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>;
+}