Initial add from apps

packages/ui-keyring/src/defaults.ts

@@ -0,0 +1,34 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { u8aToHex } from '@polkadot/util';
+import { decodeAddress } from '@polkadot/keyring';
+
+const ACCOUNT_PREFIX = 'account:';
+const ADDRESS_PREFIX = 'address:';
+const MAX_PASS_LEN = 32;
+
+function toHex (address: string): string {
+  return u8aToHex(
+    decodeAddress(address)
+  );
+}
+
+const accountKey = (address: string): string =>
+  `${ACCOUNT_PREFIX}${toHex(address)}`;
+
+const addressKey = (address: string): string =>
+  `${ADDRESS_PREFIX}${toHex(address)}`;
+
+const accountRegex = new RegExp(`^${ACCOUNT_PREFIX}`, '');
+
+const addressRegex = new RegExp(`^${ADDRESS_PREFIX}`, '');
+
+export {
+  accountKey,
+  accountRegex,
+  addressKey,
+  addressRegex,
+  MAX_PASS_LEN
+};

packages/ui-keyring/src/index.ts

@@ -0,0 +1,337 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Prefix } from '@polkadot/keyring/address/types';
+import { KeyringInstance as BaseKeyringInstance, KeyringPair, KeyringPair$Meta, KeyringPair$Json } from '@polkadot/keyring/types';
+import { AccountSubject, AddressSubject, SingleAddress } from './observable/types';
+import { KeyringAddress, KeyringJson, KeyringJson$Meta, KeyringStruct } from './types';
+
+import store from 'store';
+import createPair from '@polkadot/keyring/pair';
+import testKeyring from '@polkadot/keyring/testing';
+import { hexToU8a, isHex, isString } from '@polkadot/util';
+
+import accounts from './observable/accounts';
+import addresses from './observable/addresses';
+import env from './observable/development';
+import { accountKey, addressKey, accountRegex, addressRegex, MAX_PASS_LEN } from './defaults';
+import keyringOption from './options';
+
+// No accounts (or test accounts) should be loaded until after the chain determination.
+// Chain determination occurs outside of Keyring. Loading `keyring.loadAll()` is triggered
+// from the API after the chain is received
+class Keyring implements KeyringStruct {
+  private _accounts: AccountSubject;
+  private _addresses: AddressSubject;
+  private _keyring?: BaseKeyringInstance;
+  private _prefix: Prefix;
+
+  constructor () {
+    this._accounts = accounts;
+    this._addresses = addresses;
+    this._keyring = undefined;
+    this._prefix = 42;
+  }
+
+  get accounts () {
+    return this._accounts;
+  }
+
+  get addresses () {
+    return this._addresses;
+  }
+
+  get keyring (): BaseKeyringInstance {
+    if (this._keyring) {
+      return this._keyring;
+    }
+
+    throw new Error(`Keyring should be initialised via 'loadAll' before use`);
+  }
+
+  decodeAddress (key: string | Uint8Array): Uint8Array {
+    return this.keyring.decodeAddress(key);
+  }
+
+  encodeAddress (key: string | Uint8Array): string {
+    return this.keyring.encodeAddress(key);
+  }
+
+  setAddressPrefix (prefix: number): void {
+    this._prefix = prefix as Prefix;
+  }
+
+  private setKeyring (keyring: BaseKeyringInstance): void {
+    this._keyring = keyring;
+  }
+
+  private addAccountPairs (): void {
+    this.keyring
+      .getPairs()
+      .forEach((pair: KeyringPair) => {
+        const address = pair.address();
+
+        this.accounts.add(address, {
+          address,
+          meta: pair.getMeta()
+        });
+      });
+  }
+
+  private addTimestamp (pair: KeyringPair): void {
+    if (!pair.getMeta().whenCreated) {
+      pair.setMeta({
+        whenCreated: Date.now()
+      });
+    }
+  }
+
+  addAccountPair (pair: KeyringPair, password: string): KeyringPair {
+    this.keyring.addPair(pair);
+    this.saveAccount(pair, password);
+
+    return pair;
+  }
+
+  backupAccount (pair: KeyringPair, password: string): KeyringPair$Json {
+    if (!pair.isLocked()) {
+      pair.lock();
+    }
+
+    pair.decodePkcs8(password);
+
+    return pair.toJson(password);
+  }
+
+  createAccount (seed: Uint8Array, password?: string, meta: KeyringPair$Meta = {}): KeyringPair {
+    const pair = this.keyring.addFromSeed(seed, meta);
+
+    this.saveAccount(pair, password);
+
+    return pair;
+  }
+
+  createAccountMnemonic (seed: string, password?: string, meta: KeyringPair$Meta = {}): KeyringPair {
+    const pair = this.keyring.addFromMnemonic(seed, meta);
+
+    this.saveAccount(pair, password);
+
+    return pair;
+  }
+
+  encryptAccount (pair: KeyringPair, password: string): void {
+    const json = pair.toJson(password);
+
+    json.meta.whenEdited = Date.now();
+
+    this.keyring.addFromJson(json);
+    this.accounts.add(json.address, json);
+  }
+
+  forgetAccount (address: string): void {
+    this.keyring.removePair(address);
+    this.accounts.remove(address);
+  }
+
+  forgetAddress (address: string): void {
+    this.addresses.remove(address);
+  }
+
+  getAccount (address: string | Uint8Array): KeyringAddress {
+    return this.getAddress(address, 'account');
+  }
+
+  getAccounts (): Array<KeyringAddress> {
+    const available = this.accounts.subject.getValue();
+
+    return Object
+      .keys(available)
+      .map((address) =>
+        this.getAddress(address, 'account')
+      )
+      .filter((account) =>
+        env.isDevelopment() || account.getMeta().isTesting !== true
+      );
+  }
+
+  getAddress (_address: string | Uint8Array, type: 'account' | 'address' = 'address'): KeyringAddress {
+    const address = isString(_address)
+      ? _address
+      : this.encodeAddress(_address);
+    const publicKey = this.decodeAddress(address);
+    const subject = type === 'account'
+      ? this.accounts.subject
+      : this.addresses.subject;
+
+    return {
+      address: (): string =>
+        address,
+      isValid: (): boolean =>
+        !!subject.getValue()[address],
+      publicKey: (): Uint8Array =>
+        publicKey,
+      getMeta: (): KeyringJson$Meta =>
+        subject.getValue()[address].json.meta
+    };
+  }
+
+  getAddresses (): Array<KeyringAddress> {
+    const available = this.addresses.subject.getValue();
+
+    return Object
+      .keys(available)
+      .map((address) =>
+        this.getAddress(address)
+      );
+  }
+
+  getPair (address: string | Uint8Array): KeyringPair {
+    return this.keyring.getPair(address);
+  }
+
+  getPairs (): Array<KeyringPair> {
+    return this.keyring.getPairs().filter((pair: KeyringPair) =>
+      env.isDevelopment() || pair.getMeta().isTesting !== true
+    );
+  }
+
+  isAvailable (_address: Uint8Array | string): boolean {
+    const accountsValue = this.accounts.subject.getValue();
+    const addressesValue = this.addresses.subject.getValue();
+    const address = isString(_address)
+      ? _address
+      : this.encodeAddress(_address);
+
+    return !accountsValue[address] && !addressesValue[address];
+  }
+
+  isPassValid (password: string): boolean {
+    return password.length > 0 && password.length <= MAX_PASS_LEN;
+  }
+
+  loadAll (): void {
+    const keyring = testKeyring();
+
+    keyring.setAddressPrefix(this._prefix);
+
+    this.setKeyring(keyring);
+    this.addAccountPairs();
+
+    store.each((json: KeyringJson, key: string) => {
+      if (accountRegex.test(key)) {
+        if (!json.meta.isTesting && (json as KeyringPair$Json).encoded) {
+          const pair = keyring.addFromJson(json as KeyringPair$Json);
+
+          this.accounts.add(pair.address(), json);
+        }
+
+        const [, hexAddr] = key.split(':');
+
+        if (hexAddr.substr(0, 2) !== '0x') {
+          store.remove(key);
+          store.set(accountKey(hexAddr), json);
+        }
+      } else if (addressRegex.test(key)) {
+        const address = this.encodeAddress(
+          isHex(json.address)
+            ? hexToU8a(json.address)
+            : this.decodeAddress(json.address)
+        );
+        const [, hexAddr] = key.split(':');
+
+        this.addresses.add(address, json);
+
+        if (hexAddr.substr(0, 2) !== '0x') {
+          store.remove(key);
+          store.set(addressKey(hexAddr), json);
+        }
+      }
+    });
+
+    keyringOption.init(this);
+  }
+
+  restoreAccount (json: KeyringPair$Json, password: string): KeyringPair {
+    const pair = createPair(
+      {
+        publicKey: this.decodeAddress(json.address),
+        secretKey: new Uint8Array()
+      },
+      json.meta,
+      hexToU8a(json.encoded)
+    );
+
+    // unlock, save account and then lock (locking cleans secretKey, so needs to be last)
+    pair.decodePkcs8(password);
+    this.addAccountPair(pair, password);
+    pair.lock();
+
+    return pair;
+  }
+
+  saveAccount (pair: KeyringPair, password?: string): void {
+    this.addTimestamp(pair);
+
+    const json = pair.toJson(password);
+
+    this.keyring.addFromJson(json);
+    this.accounts.add(json.address, json);
+  }
+
+  saveAccountMeta (pair: KeyringPair, meta: KeyringPair$Meta): void {
+    const address = pair.address();
+    const json = store.get(accountKey(address));
+
+    pair.setMeta(meta);
+    json.meta = pair.getMeta();
+
+    this.accounts.add(json.address, json);
+  }
+
+  saveAddress (address: string, meta: KeyringPair$Meta): void {
+    const available = this.addresses.subject.getValue();
+
+    const json = (available[address] && available[address].json) || {
+      address,
+      meta: {
+        isRecent: void 0,
+        whenCreated: Date.now()
+      }
+    };
+
+    Object.keys(meta).forEach((key) => {
+      json.meta[key] = meta[key];
+    });
+
+    delete json.meta.isRecent;
+
+    this.addresses.add(address, json);
+  }
+
+  saveRecent (address: string): SingleAddress {
+    const available = this.addresses.subject.getValue();
+
+    if (!available[address]) {
+      const json = {
+        address,
+        meta: {
+          isRecent: true,
+          whenCreated: Date.now()
+        }
+      };
+
+      this.addresses.add(address, (json as KeyringJson));
+    }
+
+    return this.addresses.subject.getValue()[address];
+  }
+
+  setDevMode (isDevelopment: boolean): void {
+    env.set(isDevelopment);
+  }
+}
+
+const keyringInstance = new Keyring();
+
+export default keyringInstance;

packages/ui-keyring/src/observable/accounts.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { accountKey } from '../defaults';
+
+import genericSubject from './genericSubject';
+
+export default genericSubject(accountKey, true);

packages/ui-keyring/src/observable/addresses.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { addressKey } from '../defaults';
+
+import genericSubject from './genericSubject';
+
+export default genericSubject(addressKey);

packages/ui-keyring/src/observable/development.ts

@@ -0,0 +1,16 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { BehaviorSubject } from 'rxjs';
+
+const subject = new BehaviorSubject(false);
+
+export default {
+  isDevelopment: (): boolean =>
+    subject.getValue(),
+  set: (isDevelopment: boolean): void => {
+    subject.next(isDevelopment);
+  },
+  subject
+};

packages/ui-keyring/src/observable/genericSubject.ts

@@ -0,0 +1,61 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { BehaviorSubject } from 'rxjs';
+import { SubjectInfo, AddressSubject, SingleAddress } from './types';
+import { KeyringJson } from '../types';
+
+import store from 'store';
+
+import createOptionItem from '../options/item';
+import development from './development';
+
+export default function genericSubject (keyCreator: (address: string) => string, withTest: boolean = false): AddressSubject {
+  let current: SubjectInfo = {};
+  const subject = new BehaviorSubject({});
+  const next = (): void => {
+    const isDevMode = development.isDevelopment();
+
+    subject.next(
+      Object
+        .keys(current)
+        .reduce((filtered, key) => {
+          const { json: { meta: { isTesting = false } = {} } = {} } = current[key];
+
+          if (!withTest || isDevMode || isTesting !== true) {
+            filtered[key] = current[key];
+          }
+
+          return filtered;
+        }, {} as SubjectInfo)
+    );
+  };
+
+  development.subject.subscribe(next);
+
+  return {
+    add: (address: string, json: KeyringJson): SingleAddress => {
+      current = { ...current };
+
+      current[address] = {
+        json,
+        option: createOptionItem(address, json.meta.name)
+      };
+
+      store.set(keyCreator(address), json);
+      next();
+
+      return current[address];
+    },
+    remove: (address: string) => {
+      current = { ...current };
+
+      delete current[address];
+
+      store.remove(keyCreator(address));
+      next();
+    },
+    subject
+  };
+}

packages/ui-keyring/src/observable/index.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import accounts from './accounts';
+import addresses from './addresses';
+
+export default combineLatest(
+  accounts.subject,
+  addresses.subject
+).pipe(
+  map(([accounts, addresses]) => ({
+    accounts,
+    addresses
+  }))
+);

packages/ui-keyring/src/observable/types.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { BehaviorSubject } from 'rxjs';
+import { KeyringSectionOption } from '../options/types';
+import { KeyringJson } from '../types';
+
+export type SingleAccount = {
+  json: KeyringJson,
+  option: KeyringSectionOption
+};
+
+export type SingleAddress = {
+  json: KeyringJson,
+  option: KeyringSectionOption
+};
+
+export type SubjectInfo = {
+  [index: string]: SingleAddress
+};
+
+export type AccountSubject = {
+  add: (account: string, json: KeyringJson) => SingleAccount,
+  remove: (account: string) => void,
+  subject: BehaviorSubject<SubjectInfo>
+};
+
+export type AddressSubject = {
+  add: (address: string, json: KeyringJson) => SingleAddress,
+  remove: (address: string) => void,
+  subject: BehaviorSubject<SubjectInfo>
+};

packages/ui-keyring/src/options/KeyPair.css

@@ -0,0 +1,47 @@
+/* Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+/* This software may be modified and distributed under the terms
+/* of the Apache-2.0 license. See the LICENSE file for details. */
+
+.ui--KeyPair {
+  display: flex;
+  flex-wrap: nowrap;
+  justify-content: space-between;
+  position: relative;
+  white-space: nowrap;
+}
+
+.ui--KeyPair-icon {
+  position: absolute;
+  top: -9px;
+  left: 0;
+}
+
+.ui--KeyPair-address,
+.ui--KeyPair-name {
+  display: inline-block;
+}
+
+.ui--KeyPair-address {
+  flex: 1;
+  font-family: monospace;
+  margin-left: 1rem;
+  opacity: 0.5;
+  overflow: hidden;
+  text-align: right;
+  text-overflow: ellipsis;
+}
+
+.ui--KeyPair-name {
+  flex: 1 0;
+  margin-left: 3rem;
+  overflow: hidden;
+  text-transform: uppercase;
+  text-overflow: ellipsis;
+}
+
+.ui.dropdown .menu > .disabled.item.ui--KeyPair-header {
+  font-size: .75em;
+  font-weight: 700;
+  opacity: 1;
+  text-transform: uppercase;
+}

packages/ui-keyring/src/options/KeyPair.tsx

@@ -0,0 +1,54 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import './KeyPair.css';
+
+import React from 'react';
+import { AccountId } from '@polkadot/types';
+import IdentityIcon from '@polkadot/ui-app/IdentityIcon';
+import { withMulti, withObservable } from '@polkadot/ui-react-rx/with/index';
+
+type Props = {
+  address: string,
+  className?: string,
+  name: string,
+  sessionValidators?: Array<AccountId>,
+  style?: {
+    [index: string]: string
+  }
+};
+
+class KeyPair extends React.PureComponent<Props> {
+  render () {
+    const { address, className, name, sessionValidators = [], style } = this.props;
+    const isValidator = sessionValidators.find((validator) =>
+      validator.toString() === address
+    );
+
+    return (
+      <div
+        className={['ui--KeyPair', className].join(' ')}
+        style={style}
+      >
+        <IdentityIcon
+          className='ui--KeyPair-icon'
+          isHighlight={!!isValidator}
+          size={32}
+          value={address}
+        />
+        <div className='ui--KeyPair-name'>
+          {name}
+        </div>
+        <div className='ui--KeyPair-address'>
+          {address}
+        </div>
+      </div>
+    );
+  }
+}
+
+export default withMulti(
+  KeyPair,
+  withObservable('sessionValidators')
+);

packages/ui-keyring/src/options/index.spec.js

@@ -0,0 +1,18 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import keyringOptionInstance from './index';
+
+describe('KeyringOption', () => {
+  it('should not allow initOptions to be called more than once', () => {
+    const state = {};
+    // first call
+    keyringOptionInstance.init(state);
+
+    // second call
+    expect(() => {
+      keyringOptionInstance.init(state);
+    }).toThrowError('Unable to initialise options more than once');
+  });
+});

packages/ui-keyring/src/options/index.ts

@@ -0,0 +1,110 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { KeyringStruct } from '../types';
+import { SingleAddress } from '../observable/types';
+import { KeyringOptions, KeyringOptionInstance, KeyringSectionOption, KeyringSectionOptions } from './types';
+
+import { BehaviorSubject } from 'rxjs';
+
+import observableAll from '../observable';
+
+let hasCalledInitOptions = false;
+
+class KeyringOption implements KeyringOptionInstance {
+  optionsSubject: BehaviorSubject<KeyringOptions> = new BehaviorSubject(this.emptyOptions());
+
+  createOptionHeader (name: string): KeyringSectionOption {
+    return {
+      className: 'header disabled',
+      name,
+      key: `header-${name.toLowerCase()}`,
+      text: name,
+      value: null
+    };
+  }
+
+  init (keyring: KeyringStruct): void {
+    if (hasCalledInitOptions) {
+      throw new Error('Unable to initialise options more than once');
+    }
+
+    observableAll.subscribe((value) => {
+      const options = this.emptyOptions();
+
+      this.addAccounts(keyring, options);
+      this.addAddresses(keyring, options);
+
+      options.address = ([] as KeyringSectionOptions).concat(
+        options.address.length ? [ this.createOptionHeader('Addresses') ] : [],
+        options.address,
+        options.recent.length ? [ this.createOptionHeader('Recent') ] : [],
+        options.recent
+      );
+      options.account = ([] as KeyringSectionOptions).concat(
+        options.account.length ? [ this.createOptionHeader('Accounts') ] : [],
+        options.account,
+        options.testing.length ? [ this.createOptionHeader('Development') ] : [],
+        options.testing
+      );
+
+      options.all = ([] as KeyringSectionOptions).concat(
+        options.account,
+        options.address
+      );
+
+      this.optionsSubject.next(options);
+    });
+
+    hasCalledInitOptions = true;
+  }
+
+  private addAccounts (keyring: KeyringStruct, options: KeyringOptions): void {
+    const available = keyring.accounts.subject.getValue();
+
+    Object
+      .keys(available)
+      .map((address) =>
+        available[address]
+      )
+      .forEach(({ json: { meta: { isTesting = false } }, option }: SingleAddress) => {
+        if (!isTesting) {
+          options.account.push(option);
+        } else {
+          options.testing.push(option);
+        }
+      });
+  }
+
+  private addAddresses (keyring: KeyringStruct, options: KeyringOptions): void {
+    const available = keyring.addresses.subject.getValue();
+
+    Object
+      .keys(available)
+      .map((address) =>
+        available[address]
+      )
+      .forEach(({ json: { meta: { isRecent = false } }, option }: SingleAddress) => {
+        if (isRecent) {
+          options.recent.push(option);
+        } else {
+          options.address.push(option);
+        }
+      });
+  }
+
+  private emptyOptions (): KeyringOptions {
+    return {
+      account: [],
+      address: [],
+      all: [],
+      recent: [],
+      testing: []
+    };
+  }
+}
+
+const keyringOptionInstance = new KeyringOption();
+
+export default keyringOptionInstance;

packages/ui-keyring/src/options/item.tsx

@@ -0,0 +1,28 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { KeyringSectionOption } from './types';
+
+import React from 'react';
+import toShortAddress from '@polkadot/ui-app/util/toShortAddress';
+
+import KeyPair from './KeyPair';
+
+export default function createItem (address: string, _name?: string): KeyringSectionOption {
+  const name = _name === undefined
+    ? toShortAddress(address)
+    : _name;
+
+  return {
+    key: address,
+    name,
+    text: (
+      <KeyPair
+        address={address}
+        name={name}
+      />
+    ),
+    value: address
+  };
+}

packages/ui-keyring/src/options/types.ts

@@ -0,0 +1,32 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { KeyringStruct } from '../types';
+
+export type KeyringSectionOption = {
+  className?: string,
+  disabled?: boolean,
+  content?: any | string, // node?
+  key: string | null,
+  name: string,
+  text: any | string, // node?
+  value: string | null
+};
+
+export type KeyringSectionOptions = Array<KeyringSectionOption>;
+
+export type KeyringOptions = {
+  account: KeyringSectionOptions,
+  address: KeyringSectionOptions,
+  all: KeyringSectionOptions,
+  recent: KeyringSectionOptions,
+  testing: KeyringSectionOptions
+};
+
+export type KeyringOption$Type = keyof KeyringOptions;
+
+export interface KeyringOptionInstance {
+  createOptionHeader: (name: string) => KeyringSectionOption;
+  init: (keyring: KeyringStruct) => void;
+}

packages/ui-keyring/src/types.ts

@@ -0,0 +1,57 @@
+// Copyright 2017-2018 @polkadot/ui-keyring authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { KeyringInstance as BaseKeyringInstance, KeyringPair, KeyringPair$Meta, KeyringPair$Json } from '@polkadot/keyring/types';
+import { AccountSubject, AddressSubject, SingleAddress } from './observable/types';
+
+export type KeyringJson$Meta = {
+  isRecent?: boolean,
+  isTesting?: boolean,
+  name?: string,
+  whenCreated?: number,
+  whenEdited?: number,
+  whenUsed?: number,
+  [index: string]: any
+};
+
+export type KeyringJson = {
+  address: string,
+  meta: KeyringJson$Meta
+};
+
+export type KeyringAddress = {
+  address: () => string,
+  isValid: () => boolean,
+  publicKey: () => Uint8Array,
+  getMeta: () => KeyringJson$Meta
+};
+
+export interface KeyringStruct {
+  readonly accounts: AccountSubject;
+  readonly addresses: AddressSubject;
+  readonly keyring: BaseKeyringInstance | undefined;
+
+  addAccountPair: (pair: KeyringPair, password: string) => KeyringPair;
+  backupAccount: (pair: KeyringPair, password: string) => KeyringPair$Json;
+  createAccount: (seed: Uint8Array, password?: string, meta?: KeyringPair$Meta) => KeyringPair;
+  createAccountMnemonic: (seed: string, password?: string, meta?: KeyringPair$Meta) => KeyringPair;
+  encryptAccount: (pair: KeyringPair, password: string) => void;
+  forgetAccount: (address: string) => void;
+  forgetAddress: (address: string) => void;
+  getAccount: (address: string | Uint8Array) => KeyringAddress;
+  getAccounts: () => Array<KeyringAddress>;
+  getAddress: (address: string | Uint8Array) => KeyringAddress;
+  getAddresses: () => Array<KeyringAddress>;
+  getPair: (address: string | Uint8Array) => KeyringPair;
+  getPairs: () => Array<KeyringPair>;
+  isAvailable: (address: string | Uint8Array) => boolean;
+  isPassValid: (password: string) => boolean;
+  loadAll: () => void;
+  restoreAccount: (json: KeyringPair$Json, password: string) => KeyringPair;
+  saveAccount: (pair: KeyringPair, password?: string) => void;
+  saveAccountMeta: (pair: KeyringPair, meta: KeyringPair$Meta) => void;
+  saveAddress: (address: string, meta: KeyringPair$Meta) => void;
+  saveRecent: (address: string) => SingleAddress;
+  setDevMode: (isDevelopment: boolean) => void;
+}