@pezkuwi/ui-keyring 3.16.6

package/build/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/stores/index.d.ts

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

package/build/stores/index.js

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

package/build/types.d.ts

@@ -0,0 +1,78 @@
+import type { KeyringInstance as BaseKeyringInstance, KeyringOptions as KeyringOptionsBase, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@pezkuwi/keyring/types';
+import type { HexString } from '@pezkuwi/util/types';
+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';
+export type ContractMeta = NonNullable<KeyringPair$Meta['contract']>;
+export type KeyringJson$Meta = KeyringPair$Meta;
+export interface KeyringJson {
+    address: string;
+    meta: KeyringJson$Meta;
+}
+export interface KeyringPairs$Json extends EncryptedJson {
+    accounts: KeyringJson[];
+}
+export interface KeyringStore {
+    all: (cb: (key: string, value: KeyringJson) => void) => void;
+    get: (key: string, cb: (value: KeyringJson) => void) => void;
+    remove: (key: string, cb?: () => void) => void;
+    set: (key: string, value: KeyringJson, cb?: () => void) => void;
+}
+export interface KeyringOptions extends KeyringOptionsBase {
+    filter?: (json: KeyringJson) => boolean;
+    genesisHash?: HexString | {
+        toHex: () => HexString;
+    };
+    genesisHashAdd?: HexString[];
+    isDevelopment?: boolean;
+    store?: KeyringStore;
+}
+export interface KeyringAddress {
+    readonly address: string;
+    readonly meta: KeyringJson$Meta;
+    readonly publicKey: Uint8Array;
+}
+export type KeyringAddressType = 'address' | 'contract';
+export type KeyringItemType = 'account' | KeyringAddressType;
+export interface CreateResult {
+    json: KeyringPair$Json;
+    pair: KeyringPair;
+}
+export interface KeyringStruct {
+    readonly accounts: AddressSubject;
+    readonly addresses: AddressSubject;
+    readonly contracts: AddressSubject;
+    readonly keyring: BaseKeyringInstance | undefined;
+    readonly genesisHash?: string | undefined;
+    addExternal: (publicKey: Uint8Array, 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>;
+    createFromUri(suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+    decodeAddress: (key: string | Uint8Array) => Uint8Array;
+    encodeAddress: (key: string | Uint8Array) => string;
+    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: (genesisHash?: string) => KeyringAddress[];
+    getPair: (address: string | Uint8Array) => KeyringPair;
+    getPairs: () => KeyringPair[];
+    isAvailable: (address: string | Uint8Array) => boolean;
+    isPassValid: (password: string) => boolean;
+    loadAll: (options: KeyringOptions) => 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) => KeyringPair$Json;
+    saveContract: (address: string, meta: KeyringPair$Meta) => KeyringPair$Json;
+    saveRecent: (address: string) => SingleAddress;
+    setDevMode: (isDevelopment: boolean) => void;
+}

package/build/types.js

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

package/build-tsc/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-tsc/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-tsc/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-tsc/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-tsc/index.d.ts

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

package/build-tsc/observable/accounts.d.ts

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

package/build-tsc/observable/addresses.d.ts

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

package/build-tsc/observable/contracts.d.ts

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

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

package/build-tsc/observable/index.d.ts

@@ -0,0 +1,8 @@
+import type { SubjectInfo } from './types.js';
+interface Result {
+    accounts: SubjectInfo;
+    addresses: SubjectInfo;
+    contracts: SubjectInfo;
+}
+export declare const obervableAll: import("rxjs").Observable<Result>;
+export {};

package/build-tsc/observable/types.d.ts

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

package/build-tsc/options/index.d.ts

@@ -0,0 +1,15 @@
+import type { KeyringStruct } from '../types.js';
+import type { KeyringOptionInstance, KeyringOptions, KeyringSectionOption } from './types.js';
+import { BehaviorSubject } from 'rxjs';
+export declare class KeyringOption implements KeyringOptionInstance {
+    #private;
+    readonly optionsSubject: BehaviorSubject<KeyringOptions>;
+    createOptionHeader(name: string): KeyringSectionOption;
+    init(keyring: KeyringStruct): void;
+    clear(): void;
+    private linkItems;
+    private addAccounts;
+    private addAddresses;
+    private addContracts;
+    private emptyOptions;
+}

package/build-tsc/options/item.d.ts

@@ -0,0 +1,2 @@
+import type { KeyringSectionOption } from './types.js';
+export declare function createOptionItem(address: string, _name?: string): KeyringSectionOption;

package/build-tsc/options/types.d.ts

@@ -0,0 +1,15 @@
+import type { KeyringItemType, KeyringStruct } from '../types.js';
+export interface KeyringSectionOption {
+    key: string | null;
+    name: string;
+    value: string | null;
+}
+export type KeyringSectionOptions = KeyringSectionOption[];
+export type KeyringOptions = {
+    [type in KeyringItemType | 'all' | 'allPlus' | 'recent' | 'testing']: KeyringSectionOptions;
+};
+export type KeyringOption$Type = keyof KeyringOptions;
+export interface KeyringOptionInstance {
+    createOptionHeader: (name: string) => KeyringSectionOption;
+    init: (keyring: KeyringStruct) => void;
+}

package/build-tsc/packageDetect.d.ts

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

package/build-tsc/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/build-tsc/stores/Browser.d.ts

@@ -0,0 +1,7 @@
+import type { KeyringJson, KeyringStore } from '../types.js';
+export declare class BrowserStore implements KeyringStore {
+    all(fn: (key: string, value: KeyringJson) => void): void;
+    get(key: string, fn: (value: KeyringJson) => void): void;
+    remove(key: string, fn?: () => void): void;
+    set(key: string, value: KeyringJson, fn?: () => void): void;
+}

package/build-tsc/stores/File.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringJson, KeyringStore } from '../types.js';
+export declare class FileStore implements KeyringStore {
+    #private;
+    constructor(path: string);
+    private validateKey;
+    all(fn: (key: string, value: KeyringJson) => void): void;
+    get(key: string, fn: (value: KeyringJson) => void): void;
+    remove(key: string, fn?: () => void): void;
+    set(key: string, value: KeyringJson, fn?: () => void): void;
+    private _getPath;
+    private _readKey;
+}

package/build-tsc/stores/index.d.ts

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

package/build-tsc/types.d.ts

@@ -0,0 +1,78 @@
+import type { KeyringInstance as BaseKeyringInstance, KeyringOptions as KeyringOptionsBase, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@pezkuwi/keyring/types';
+import type { HexString } from '@pezkuwi/util/types';
+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';
+export type ContractMeta = NonNullable<KeyringPair$Meta['contract']>;
+export type KeyringJson$Meta = KeyringPair$Meta;
+export interface KeyringJson {
+    address: string;
+    meta: KeyringJson$Meta;
+}
+export interface KeyringPairs$Json extends EncryptedJson {
+    accounts: KeyringJson[];
+}
+export interface KeyringStore {
+    all: (cb: (key: string, value: KeyringJson) => void) => void;
+    get: (key: string, cb: (value: KeyringJson) => void) => void;
+    remove: (key: string, cb?: () => void) => void;
+    set: (key: string, value: KeyringJson, cb?: () => void) => void;
+}
+export interface KeyringOptions extends KeyringOptionsBase {
+    filter?: (json: KeyringJson) => boolean;
+    genesisHash?: HexString | {
+        toHex: () => HexString;
+    };
+    genesisHashAdd?: HexString[];
+    isDevelopment?: boolean;
+    store?: KeyringStore;
+}
+export interface KeyringAddress {
+    readonly address: string;
+    readonly meta: KeyringJson$Meta;
+    readonly publicKey: Uint8Array;
+}
+export type KeyringAddressType = 'address' | 'contract';
+export type KeyringItemType = 'account' | KeyringAddressType;
+export interface CreateResult {
+    json: KeyringPair$Json;
+    pair: KeyringPair;
+}
+export interface KeyringStruct {
+    readonly accounts: AddressSubject;
+    readonly addresses: AddressSubject;
+    readonly contracts: AddressSubject;
+    readonly keyring: BaseKeyringInstance | undefined;
+    readonly genesisHash?: string | undefined;
+    addExternal: (publicKey: Uint8Array, 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>;
+    createFromUri(suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+    decodeAddress: (key: string | Uint8Array) => Uint8Array;
+    encodeAddress: (key: string | Uint8Array) => string;
+    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: (genesisHash?: string) => KeyringAddress[];
+    getPair: (address: string | Uint8Array) => KeyringPair;
+    getPairs: () => KeyringPair[];
+    isAvailable: (address: string | Uint8Array) => boolean;
+    isPassValid: (password: string) => boolean;
+    loadAll: (options: KeyringOptions) => 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) => KeyringPair$Json;
+    saveContract: (address: string, meta: KeyringPair$Meta) => KeyringPair$Json;
+    saveRecent: (address: string) => SingleAddress;
+    setDevMode: (isDevelopment: boolean) => void;
+}

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