@pezkuwi/keyring 14.0.1 → 14.0.3

package/src/keyring.ts

@@ -1,307 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@pezkuwi/util-crypto/types';
-import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from './types.js';
-
-import { hexToU8a, isHex, stringToU8a } from '@pezkuwi/util';
-import { base64Decode, decodeAddress, ed25519PairFromSeed as ed25519FromSeed, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, secp256k1PairFromSeed as secp256k1FromSeed, sr25519PairFromSeed as sr25519FromSeed } from '@pezkuwi/util-crypto';
-
-import { createPair } from './pair/index.js';
-import { DEV_PHRASE } from './defaults.js';
-import { Pairs } from './pairs.js';
-
-const PairFromSeed = {
-  ecdsa: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
-  ed25519: (seed: Uint8Array): Keypair => ed25519FromSeed(seed),
-  ethereum: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
-  sr25519: (seed: Uint8Array): Keypair => sr25519FromSeed(seed)
-};
-
-function pairToPublic ({ publicKey }: KeyringPair): Uint8Array {
-  return publicKey;
-}
-
-/**
- * # @polkadot/keyring
- *
- * ## Overview
- *
- * @name Keyring
- * @summary Keyring management of user accounts
- * @description Allows generation of keyring pairs from a variety of input combinations, such as
- * json object containing account address or public key, account metadata, and account encoded using
- * `addFromJson`, or by providing those values as arguments separately to `addFromAddress`,
- * or by providing the mnemonic (seed phrase) and account metadata as arguments to `addFromMnemonic`.
- * Stores the keyring pairs in a keyring pair dictionary. Removal of the keyring pairs from the keyring pair
- * dictionary is achieved using `removePair`. Retrieval of all the stored pairs via `getPairs` or perform
- * lookup of a pair for a given account address or public key using `getPair`. JSON metadata associated with
- * an account may be obtained using `toJson` accompanied by the account passphrase.
- */
-export class Keyring implements KeyringInstance {
-  readonly #pairs: Pairs;
-
-  readonly #type: KeypairType;
-
-  #ss58?: number | undefined;
-
-  public decodeAddress = decodeAddress;
-
-  constructor (options: KeyringOptions = {}) {
-    options.type = options.type || 'ed25519';
-
-    if (!['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined')) {
-      throw new Error(`Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type || 'unknown'}`);
-    }
-
-    this.#pairs = new Pairs();
-    this.#ss58 = options.ss58Format;
-    this.#type = options.type;
-  }
-
-  /**
-   * @description retrieve the pairs (alias for getPairs)
-   */
-  public get pairs (): KeyringPair[] {
-    return this.getPairs();
-  }
-
-  /**
-   * @description retrieve the publicKeys (alias for getPublicKeys)
-   */
-  public get publicKeys (): Uint8Array[] {
-    return this.getPublicKeys();
-  }
-
-  /**
-   * @description Returns the type of the keyring, ed25519, sr25519 or ecdsa
-   */
-  public get type (): KeypairType {
-    return this.#type;
-  }
-
-  /**
-   * @name addPair
-   * @summary Stores an account, given a keyring pair, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   */
-  public addPair (pair: KeyringPair): KeyringPair {
-    return this.#pairs.add(pair);
-  }
-
-  /**
-   * @name addFromAddress
-   * @summary Stores an account, given an account address, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Allows user to explicitly provide separate inputs including account address or public key, and optionally
-   * the associated account metadata, and the default encoded value as arguments (that may be obtained from the json file
-   * of an account backup), and then generates a keyring pair from them that it passes to
-   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
-   */
-  public addFromAddress (address: string | Uint8Array, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, type: KeypairType = this.type, ignoreChecksum?: boolean, encType?: EncryptedJsonEncoding[]): KeyringPair {
-    const publicKey = this.decodeAddress(address, ignoreChecksum);
-
-    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded, encType));
-  }
-
-  /**
-   * @name addFromJson
-   * @summary Stores an account, given JSON data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Allows user to provide a json object argument that contains account information (that may be obtained from the json file
-   * of an account backup), and then generates a keyring pair from it that it passes to
-   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
-   */
-  public addFromJson (json: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
-    return this.addPair(this.createFromJson(json, ignoreChecksum));
-  }
-
-  /**
-   * @name addFromMnemonic
-   * @summary Stores an account, given a mnemonic, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Allows user to provide a mnemonic (seed phrase that is provided when account is originally created)
-   * argument and a metadata argument that contains account information (that may be obtained from the json file
-   * of an account backup), and then generates a keyring pair from it that it passes to
-   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
-   */
-  public addFromMnemonic (mnemonic: string, meta: KeyringPair$Meta = {}, type: KeypairType = this.type, wordlist?: string[]): KeyringPair {
-    return this.addFromUri(mnemonic, meta, type, wordlist);
-  }
-
-  /**
-   * @name addFromPair
-   * @summary Stores an account created from an explicit publicKey/secreteKey combination
-   */
-  public addFromPair (pair: Keypair, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
-    return this.addPair(
-      this.createFromPair(pair, meta, type)
-    );
-  }
-
-  /**
-   * @name addFromSeed
-   * @summary Stores an account, given seed data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Stores in a keyring pair dictionary the public key of the pair as a key and the pair as the associated value.
-   * Allows user to provide the account seed as an argument, and then generates a keyring pair from it that it passes to
-   * `addPair` to store in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
-   */
-  public addFromSeed (seed: Uint8Array, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
-    return this.addPair(
-      createPair({ toSS58: this.encodeAddress, type }, PairFromSeed[type](seed), meta, null)
-    );
-  }
-
-  /**
-   * @name addFromUri
-   * @summary Creates an account via an suri
-   * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed). The secret can be a hex string, mnemonic phrase or a string (to be padded)
-   */
-  public addFromUri (suri: string, meta: KeyringPair$Meta = {}, type: KeypairType = this.type, wordlist?: string[]): KeyringPair {
-    return this.addPair(
-      this.createFromUri(suri, meta, type, wordlist)
-    );
-  }
-
-  /**
-   * @name createFromJson
-   * @description Creates a pair from a JSON keyfile
-   */
-  public createFromJson ({ address, encoded, encoding: { content, type, version }, meta }: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
-    if (version === '3' && content[0] !== 'pkcs8') {
-      throw new Error(`Unable to decode non-pkcs8 type, [${content.join(',')}] found}`);
-    }
-
-    const cryptoType = version === '0' || !Array.isArray(content)
-      ? this.type
-      : content[1];
-    const encType = !Array.isArray(type)
-      ? [type]
-      : type;
-
-    if (!['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(cryptoType)) {
-      throw new Error(`Unknown crypto type ${cryptoType}`);
-    }
-
-    // Here the address and publicKey are 32 bytes and isomorphic. This is why the address field needs to be the public key for ethereum type pairs
-    const publicKey = isHex(address)
-      ? hexToU8a(address)
-      : this.decodeAddress(address, ignoreChecksum);
-    const decoded = isHex(encoded)
-      ? hexToU8a(encoded)
-      : base64Decode(encoded);
-
-    return createPair({ toSS58: this.encodeAddress, type: cryptoType as KeypairType }, { publicKey, secretKey: new Uint8Array() }, meta, decoded, encType);
-  }
-
-  /**
-   * @name createFromPair
-   * @summary Creates a pair from an explicit publicKey/secreteKey combination
-   */
-  public createFromPair (pair: Keypair, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
-    return createPair({ toSS58: this.encodeAddress, type }, pair, meta, null);
-  }
-
-  /**
-   * @name createFromUri
-   * @summary Creates a Keypair from an suri
-   * @description This creates a pair from the suri, but does not add it to the keyring
-   */
-  public createFromUri (_suri: string, meta: KeyringPair$Meta = {}, type: KeypairType = this.type, wordlist?: string[]): KeyringPair {
-    // here we only aut-add the dev phrase if we have a hard-derived path
-    const suri = _suri.startsWith('//')
-      ? `${DEV_PHRASE}${_suri}`
-      : _suri;
-    const { derivePath, password, path, phrase } = keyExtractSuri(suri);
-    let seed: Uint8Array;
-    const isPhraseHex = isHex(phrase, 256);
-
-    if (isPhraseHex) {
-      seed = hexToU8a(phrase);
-    } else {
-      const parts = phrase.split(' ');
-
-      if ([12, 15, 18, 21, 24].includes(parts.length)) {
-        seed = type === 'ethereum'
-          ? mnemonicToLegacySeed(phrase, '', false, 64)
-          : mnemonicToMiniSecret(phrase, password, wordlist);
-      } else {
-        if (phrase.length > 32) {
-          throw new Error('specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');
-        }
-
-        seed = stringToU8a(phrase.padEnd(32));
-      }
-    }
-
-    const derived = type === 'ethereum'
-      ? isPhraseHex
-        ? PairFromSeed[type](seed) // for eth, if the private key is provided as suri, it must be derived only once
-        : hdEthereum(seed, derivePath.substring(1))
-      : keyFromPath(PairFromSeed[type](seed), path, type);
-
-    return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
-  }
-
-  /**
-   * @name encodeAddress
-   * @description Encodes the input into an ss58 representation
-   */
-  public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
-    return this.type === 'ethereum'
-      ? ethereumEncode(address)
-      : encodeAddress(address, ss58Format ?? this.#ss58);
-  };
-
-  /**
-   * @name getPair
-   * @summary Retrieves an account keyring pair from the Keyring Pair Dictionary, given an account address
-   * @description Returns a keyring pair value from the keyring pair dictionary by performing
-   * a key lookup using the provided account address or public key (after decoding it).
-   */
-  public getPair (address: string | Uint8Array): KeyringPair {
-    return this.#pairs.get(address);
-  }
-
-  /**
-   * @name getPairs
-   * @summary Retrieves all account keyring pairs from the Keyring Pair Dictionary
-   * @description Returns an array list of all the keyring pair values that are stored in the keyring pair dictionary.
-   */
-  public getPairs (): KeyringPair[] {
-    return this.#pairs.all();
-  }
-
-  /**
-   * @name getPublicKeys
-   * @summary Retrieves Public Keys of all Keyring Pairs stored in the Keyring Pair Dictionary
-   * @description Returns an array list of all the public keys associated with each of the keyring pair values that are stored in the keyring pair dictionary.
-   */
-  public getPublicKeys (): Uint8Array[] {
-    return this.#pairs.all().map(pairToPublic);
-  }
-
-  /**
-   * @name removePair
-   * @description Deletes the provided input address or public key from the stored Keyring Pair Dictionary.
-   */
-  public removePair (address: string | Uint8Array): void {
-    this.#pairs.remove(address);
-  }
-
-  /**
-   * @name setSS58Format;
-   * @description Sets the ss58 format for the keyring
-   */
-  public setSS58Format (ss58: number): void {
-    this.#ss58 = ss58;
-  }
-
-  /**
-   * @name toJson
-   * @summary Returns a JSON object associated with the input argument that contains metadata assocated with an account
-   * @description Returns a JSON object containing the metadata associated with an account
-   * when valid address or public key and when the account passphrase is provided if the account secret
-   * is not already unlocked and available in memory. Note that in [Polkadot-JS Apps](https://github.com/polkadot-js/apps) the user
-   * may backup their account to a JSON file that contains this information.
-   */
-  public toJson (address: string | Uint8Array, passphrase?: string): KeyringPair$Json {
-    return this.#pairs.get(address).toJson(passphrase);
-  }
-}

package/src/mod.ts

@@ -1,4 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export * from './index.js';

package/src/packageInfo.ts

@@ -1,6 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// Do not edit, auto-generated by @polkadot/dev
-
-export const packageInfo = { name: '@polkadot/keyring', path: 'auto', type: 'auto', version: '14.0.1' };

package/src/pair/decode.spec.ts

@@ -1,26 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { createTestPairs } from '../testingPairs.js';
-
-const keyring = createTestPairs({ type: 'ed25519' }, false);
-
-describe('decode', (): void => {
-  it('fails when no data provided', (): void => {
-    expect(
-      (): void => keyring.alice.decodePkcs8()
-    ).toThrow(/No encrypted data available/);
-  });
-
-  it('returns correct publicKey from encoded', (): void => {
-    const PASS = 'testing';
-
-    expect(
-      (): void => keyring.alice.decodePkcs8(
-        PASS, keyring.alice.encodePkcs8(PASS)
-      )
-    ).not.toThrow();
-  });
-});

package/src/pair/decode.ts

@@ -1,56 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJsonEncoding } from '@pezkuwi/util-crypto/types';
-
-import { u8aEq } from '@pezkuwi/util';
-import { jsonDecryptData } from '@pezkuwi/util-crypto';
-
-import { PAIR_DIV, PAIR_HDR, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH } from './defaults.js';
-
-const SEED_OFFSET = PAIR_HDR.length;
-
-/**
- * Decode a pair, taking into account the generation-specific formats and headers
- *
- * For divisor/headers, don't rely on the magic being static. These will
- * change between generations, aka with the long-awaited 4th generation
- * of the format. The external decode interface is the only way to use and decode these.
- **/
-export function decodePair (passphrase?: string, encrypted?: Uint8Array | null, _encType?: EncryptedJsonEncoding | EncryptedJsonEncoding[]): { publicKey: Uint8Array; secretKey: Uint8Array } {
-  const encType = Array.isArray(_encType) || _encType === undefined
-    ? _encType
-    : [_encType];
-  const decrypted = jsonDecryptData(encrypted, passphrase, encType);
-  const header = decrypted.subarray(0, PAIR_HDR.length);
-
-  // check the start header (generations 1-3)
-  if (!u8aEq(header, PAIR_HDR)) {
-    throw new Error('Invalid encoding header found in body');
-  }
-
-  // setup for generation 3 format
-  let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + SEC_LENGTH);
-  let divOffset = SEED_OFFSET + SEC_LENGTH;
-  let divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
-
-  // old-style (generation 1 & 2), we have the seed here
-  if (!u8aEq(divider, PAIR_DIV)) {
-    divOffset = SEED_OFFSET + SEED_LENGTH;
-    secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
-    divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
-
-    // check the divisior at this point (already checked for generation 3)
-    if (!u8aEq(divider, PAIR_DIV)) {
-      throw new Error('Invalid encoding divider found in body');
-    }
-  }
-
-  const pubOffset = divOffset + PAIR_DIV.length;
-  const publicKey = decrypted.subarray(pubOffset, pubOffset + PUB_LENGTH);
-
-  return {
-    publicKey,
-    secretKey
-  };
-}

package/src/pair/encode.spec.ts

@@ -1,28 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { NONCE_LENGTH, SCRYPT_LENGTH } from '@pezkuwi/util-crypto/json/constants';
-
-import { createTestPairs } from '../testingPairs.js';
-import { PAIR_DIV, PAIR_HDR, PUB_LENGTH, SEC_LENGTH } from './defaults.js';
-
-const DECODED_LENGTH = PAIR_DIV.length + PAIR_HDR.length + PUB_LENGTH + SEC_LENGTH;
-const ENCODED_LENGTH = 16 + DECODED_LENGTH + NONCE_LENGTH + SCRYPT_LENGTH;
-
-const keyring = createTestPairs({ type: 'ed25519' }, false);
-
-describe('encode', (): void => {
-  it('returns PKCS8 when no passphrase supplied', (): void => {
-    expect(
-      keyring.alice.encodePkcs8()
-    ).toHaveLength(DECODED_LENGTH);
-  });
-
-  it('returns encoded PKCS8 when passphrase supplied', (): void => {
-    expect(
-      keyring.alice.encodePkcs8('testing')
-    ).toHaveLength(ENCODED_LENGTH);
-  });
-});

package/src/pair/encode.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { PairInfo } from './types.js';
-
-import { u8aConcat } from '@pezkuwi/util';
-import { naclEncrypt, scryptEncode, scryptToU8a } from '@pezkuwi/util-crypto';
-
-import { PAIR_DIV, PAIR_HDR } from './defaults.js';
-
-/**
- * Encode a pair with the latest generation format (generation 3)
- **/
-export function encodePair ({ publicKey, secretKey }: PairInfo, passphrase?: string): Uint8Array {
-  if (!secretKey) {
-    throw new Error('Expected a valid secretKey to be passed to encode');
-  }
-
-  const encoded = u8aConcat(PAIR_HDR, secretKey, PAIR_DIV, publicKey);
-
-  if (!passphrase) {
-    return encoded;
-  }
-
-  // this is only for generation 3 (previous generations are only handled in decoding)
-  const { params, password, salt } = scryptEncode(passphrase);
-  const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
-
-  return u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
-}

package/src/pair/index.spec.ts

@@ -1,189 +0,0 @@
-// Copyright 2017-2025 @polkadot/keyring authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexToU8a, u8aToHex } from '@pezkuwi/util';
-import { cryptoWaitReady, encodeAddress as toSS58, setSS58Format } from '@pezkuwi/util-crypto';
-
-import { PAIRSSR25519 } from '../testing.js';
-import { createTestPairs } from '../testingPairs.js';
-import { createPair } from './index.js';
-
-const keyring = createTestPairs({ type: 'ed25519' }, false);
-
-const TEST_ADDRESS = '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887';
-
-await cryptoWaitReady();
-
-describe('pair', (): void => {
-  const SIGNATURE = new Uint8Array([80, 191, 198, 147, 225, 207, 75, 88, 126, 39, 129, 109, 191, 38, 72, 181, 75, 254, 81, 143, 244, 79, 237, 38, 236, 141, 28, 252, 134, 26, 169, 234, 79, 33, 153, 158, 151, 34, 175, 188, 235, 20, 35, 135, 83, 120, 139, 211, 233, 130, 1, 208, 201, 215, 73, 80, 56, 98, 185, 196, 11, 8, 193, 14]);
-
-  it('has a publicKey', (): void => {
-    expect(
-      keyring.alice.publicKey
-    ).toEqual(
-      new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79])
-    );
-    expect(
-      keyring.alice.addressRaw
-    ).toEqual(
-      new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79])
-    );
-  });
-
-  it('allows signing', (): void => {
-    expect(
-      keyring.alice.sign(
-        new Uint8Array([0x61, 0x62, 0x63, 0x64])
-      )
-    ).toEqual(SIGNATURE);
-  });
-
-  it('validates a correctly signed message', (): void => {
-    expect(
-      keyring.alice.verify(
-        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
-        SIGNATURE,
-        keyring.alice.publicKey
-      )
-    ).toEqual(true);
-  });
-
-  it('fails a correctly signed message (signer changed)', (): void => {
-    expect(
-      keyring.alice.verify(
-        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
-        SIGNATURE,
-        keyring.bob.publicKey
-      )
-    ).toEqual(false);
-  });
-
-  it('fails a correctly signed message (message changed)', (): void => {
-    expect(
-      keyring.alice.verify(
-        new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
-        SIGNATURE,
-        keyring.alice.publicKey
-      )
-    ).toEqual(false);
-  });
-
-  it('allows vrf sign and verify', (): void => {
-    const message = new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]);
-
-    expect(
-      keyring.alice.vrfVerify(
-        message,
-        keyring.alice.vrfSign(message),
-        keyring.alice.publicKey
-      )
-    ).toBe(true);
-  });
-
-  it('fails vrf sign and verify (publicKey changed)', (): void => {
-    const message = new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]);
-
-    expect(
-      keyring.alice.vrfVerify(
-        message,
-        keyring.alice.vrfSign(message),
-        keyring.bob.publicKey
-      )
-    ).toBe(false);
-  });
-
-  it('allows setting/getting of meta', (): void => {
-    keyring.bob.setMeta({ foo: 'bar', something: 'else' });
-
-    expect(keyring.bob.meta).toMatchObject({ foo: 'bar', something: 'else' });
-
-    keyring.bob.setMeta({ something: 'thing' });
-
-    expect(keyring.bob.meta).toMatchObject({ foo: 'bar', something: 'thing' });
-  });
-
-  it('allows encoding of address with different prefixes', (): void => {
-    expect(keyring.alice.address).toEqual('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua');
-
-    // eslint-disable-next-line deprecation/deprecation
-    setSS58Format(255);
-
-    expect(keyring.alice.address).toEqual('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k');
-
-    // eslint-disable-next-line deprecation/deprecation
-    setSS58Format(42);
-  });
-
-  it('allows getting public key after decoding', (): void => {
-    const PASS = 'testing';
-    const encoded = keyring.alice.encodePkcs8(PASS);
-
-    const pair = createPair({ toSS58, type: 'sr25519' }, { publicKey: keyring.alice.publicKey });
-
-    pair.decodePkcs8(PASS, encoded);
-
-    expect(pair.isLocked).toEqual(false);
-  });
-
-  it('allows derivation on the pair', (): void => {
-    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: hexToU8a(PAIRSSR25519[0].p), secretKey: hexToU8a(PAIRSSR25519[0].s) }, {});
-    const stash = alice.derive('//stash');
-    const soft = alice.derive('//funding/0');
-
-    expect(stash.publicKey).toEqual(hexToU8a(PAIRSSR25519[1].p));
-    expect(soft.address).toEqual('5ECQNn7UueWHPFda5qUi4fTmTtyCnPvGnuoyVVSj5CboJh9J');
-  });
-
-  it('fails to sign when locked', (): void => {
-    const pair = createPair({ toSS58, type: 'sr25519' }, { publicKey: keyring.alice.publicKey });
-
-    expect(pair.isLocked).toEqual(true);
-    expect((): Uint8Array =>
-      pair.sign(new Uint8Array([0]))
-    ).toThrow('Cannot sign with a locked key pair');
-  });
-
-  describe('ethereum', (): void => {
-    const PUBLICDERIVED = new Uint8Array([
-      3, 129, 53, 27, 27, 70, 210, 96,
-      43, 9, 146, 187, 93, 85, 49, 249,
-      193, 105, 107, 8, 18, 254, 178, 83,
-      75, 104, 132, 173, 196, 126, 46, 29,
-      139
-    ]);
-    const SECRETDERIVED = new Uint8Array([
-      7, 13, 195, 17, 115, 0, 1, 25,
-      24, 226, 107, 2, 23, 105, 69, 204,
-      21, 195, 213, 72, 207, 73, 253, 132,
-      24, 217, 127, 147, 175, 105, 158, 70
-    ]);
-
-    it('has a valid address from a known public', (): void => {
-      const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077') });
-
-      expect(pair.address).toEqual(TEST_ADDRESS);
-      expect(pair.addressRaw).toEqual(hexToU8a(TEST_ADDRESS));
-    });
-
-    it('has a valid address from a known ethereum address (20 length)', (): void => {
-      const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: new Uint8Array([75, 32, 205, 127, 248, 119, 52, 31, 46, 171, 170, 23, 158, 23, 46, 108, 95, 180, 186, 168]), secretKey: new Uint8Array([]) });
-
-      expect(pair.address.toLowerCase()).toEqual('0x4b20cd7ff877341f2eabaa179e172e6c5fb4baa8');
-      expect(pair.addressRaw).toEqual(hexToU8a('0x4b20cd7ff877341f2eabaa179e172e6c5fb4baa8'));
-    });
-
-    it('converts to json', (): void => {
-      const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: PUBLICDERIVED, secretKey: SECRETDERIVED });
-      const json = pair.toJson('password');
-
-      expect(json.encoding).toEqual({
-        content: ['pkcs8', 'ethereum'],
-        type: ['scrypt', 'xsalsa20-poly1305'],
-        version: '3'
-      });
-      expect(json.address).toEqual(u8aToHex(PUBLICDERIVED));
-    });
-  });
-});