@pezkuwi/ui-keyring 3.16.7 → 3.16.8

package/src/Base.ts

@@ -1,156 +0,0 @@
-// 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() });
-    }
-  }
-}

package/src/Keyring.ts

@@ -1,420 +0,0 @@
-// 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

@@ -1,10 +0,0 @@
-// 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

@@ -1,34 +0,0 @@
-// 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

@@ -1,10 +0,0 @@
-// 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

@@ -1,11 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-// 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

@@ -1,15 +0,0 @@
-// 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
-};