[CI Skip] release/stable 3.1.1

skip-checks: true

.yarnrc.yml

@@ -8,4 +8,4 @@ plugins:
   - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.js
     spec: "@yarnpkg/plugin-interactive-tools"
 
-yarnPath: .yarn/releases/yarn-rc.js
+yarnPath: .yarn/releases/yarn-2.1.1.js

CHANGELOG.md

@@ -1,5 +1,40 @@
 # CHANGELOG
 
+## 3.1.1 Aug 10, 2020
+
+- Add `deriveAddress(<address>, '/<soft>/<soft-b>')` via sr25519 soft
+- Use `scrypt` from WASM as available (JS fallback in place)
+- Add `base32{Encode, Decode}` utilities (IPFS-compatible alphabet)
+- Support IPFS compatibility flag in base58 encoding/decoding
+- Update to `@polkadot/wasm-crypto` 1.3.1
+
+## 3.0.1 Jul 27, 2020
+
+- Add Katal ss58Format (Thanks to https://github.com/retotrinkler)
+- Adjust JSON pair output with scrypt kdf (version 3 output)
+
+## 2.18.1 Jul 13, 2020
+
+- Add `base64{Decode, Encode, Validate}` as crypto utils
+- Extract `base58Validate` from base58 decode checks
+- Add `isAscii` to allow detection of printable ASCII sequences (including tab, newline)
+- Add `isUtf8` to allow detection of valid Utf8 sequences
+
+## 2.17.1 Jul 6, 2020
+
+- Add `encode{Derived, Multi}Address` to encode derived/multi addresses
+- Correctly handle 0 inputs in `numberToU8a`
+- Simplify and flatten base58 dependencies
+
+## 2.16.1 Jun 29, 2020
+
+- Adjust `addressCheck` and `encodeAddress` function to check for valid base58 alphabets (better error reporting)
+- Rename `createKeySub` to `createKeyDerived` based on changed in Substrate (sub keys now named derived)
+
+## 2.15.1 Jun 22, 2020
+
+- Adjust keyring to no override 0-prefix (Polkadot live) settings with keychain default
+
 ## 2.14.1 Jun 16, 2020
 
 - Add `extractTime` utility conversion (Thanks to https://github.com/kwingram25)

lerna.json

@@ -9,5 +9,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "2.14.1"
+  "version": "3.1.1"
 }

package.json

@@ -21,10 +21,10 @@
     "test:one": "polkadot-dev-run-test"
   },
   "devDependencies": {
-    "@babel/core": "^7.10.2",
-    "@polkadot/dev": "^0.55.10",
-    "@polkadot/ts": "^0.3.26",
-    "@types/jest": "^26.0.0"
+    "@babel/core": "^7.11.1",
+    "@polkadot/dev": "^0.55.36",
+    "@polkadot/ts": "^0.3.36",
+    "@types/jest": "^26.0.9"
   },
-  "version": "2.14.1"
+  "version": "3.1.1"
 }

packages/keyring/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/keyring",
-  "version": "2.14.1",
+  "version": "3.1.1",
   "description": "Keyring management",
   "main": "index.js",
   "publishConfig": {
@@ -27,8 +27,8 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/util": "2.14.1",
-    "@polkadot/util-crypto": "2.14.1"
+    "@babel/runtime": "^7.11.2",
+    "@polkadot/util": "3.1.1",
+    "@polkadot/util-crypto": "3.1.1"
   }
 }

packages/keyring/src/index.spec.ts

@@ -212,4 +212,93 @@ describe('keypair', (): void => {
       expect(pair.verify(MESSAGE, signature)).toBe(true);
     });
   });
+
+  describe('util', (): void => {
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 42 });
+    });
+
+    it('can re-encode an address to Polkadot live', (): void => {
+      expect(
+        keyring.encodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 0)
+      ).toEqual('15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5');
+    });
+
+    it('can re-encode an address to keyring default', (): void => {
+      expect(
+        keyring.encodeAddress('15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5')
+      ).toEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
+    });
+  });
+
+  describe('version 2 JSON', (): void => {
+    const PAIR = '{"address":"5CczAE5AmGrZ93MeVhha3Ywam7j9dKB7cArnH7gtrXcMFJvu","encoded":"0xee8f236e2ac3217ce689692a4afc612220dc77fddaed0482f8f95136a7c3e034cccfbc495410a6e9b2439904974ed1d207abeca536ff6985ceb78edeeb3dc343e561c184c488101af8811d1331430b4ccf0e96ef507132e5132964e8564232e7100d973c5bee7b231dd0c8ad5273f3501515a422c8d7ed9d20a73c0ed17c98ee4588e54844bb73052dcad81f7a1094613d63c162fec7446c88b1fae70e","encoding":{"content":["pkcs8","sr25519"],"type":"xsalsa20-poly1305","version":"2"},"meta":{"genesisHash":"0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e","name":"json v2","tags":[],"whenCreated":1595243159596}}';
+    const PASS2 = 'versionTwo';
+    const PASS3 = 'versionThree';
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 42 });
+    });
+
+    it('can decode from a version 2 JSON file', (): void => {
+      const pair = keyring.addFromJson(JSON.parse(PAIR));
+
+      pair.decodePkcs8(PASS2);
+
+      const json = pair.toJson(PASS3);
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe('5CczAE5AmGrZ93MeVhha3Ywam7j9dKB7cArnH7gtrXcMFJvu');
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'sr25519'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+
+      pair.decodePkcs8(PASS3);
+
+      expect(pair.address).toEqual('5CczAE5AmGrZ93MeVhha3Ywam7j9dKB7cArnH7gtrXcMFJvu');
+    });
+  });
+
+  describe('version 3 JSON (hex)', (): void => {
+    const PAIR = '{"address":"FLiSDPCcJ6auZUGXALLj6jpahcP6adVFDBUQznPXUQ7yoqH","encoded":"0xcd238963070cc4d6806053ee1ac500c7add9c28732bb5d434a332f84a91d9be0008000000100000008000000cf630a1113941b350ddd06697e50399183162e5e9a0e893eafc7f5f4893a223dca5055706b9925b56fdb4304192143843da718e11717daf89cf4f4781f94fb443f61432f782d54280af9eec90bd3069c3cc2d957a42b7c18dc2e9497f623735518e0e49b58f8e4db2c09da3a45dbb935659d015fc94b946cba75b606a6ff7f4e823f6b049e2e6892026b49de02d6dbbd64646fe0933f537d9ea53a70be","encoding":{"content":["pkcs8","sr25519"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"version3","tags":[],"whenCreated":1595277797639}}';
+    const PASS3 = 'version3';
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 2 });
+    });
+
+    it('can decode from a version 3 JSON file', (): void => {
+      const pair = keyring.addFromJson(JSON.parse(PAIR));
+
+      pair.decodePkcs8(PASS3);
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe('FLiSDPCcJ6auZUGXALLj6jpahcP6adVFDBUQznPXUQ7yoqH');
+    });
+  });
+
+  describe('version 3 JSON (base64)', (): void => {
+    const PAIR = '{"address":"FLiSDPCcJ6auZUGXALLj6jpahcP6adVFDBUQznPXUQ7yoqH","encoded":"ILjSgYaGvq1zaCz/kx+aqfLaHBjLXz0Qsmr6RnkOVU4AgAAAAQAAAAgAAAB5R2hm5kgXyc0NQYFxvMU4zCdjB+ugs/ibEooqCvuudbaeKn3Ee47NkCqU1ecOJV+eeaVn4W4dRvIpj5kGmQOGsewR+MiQ/B0G9NFh7JXV0qcPlk2QMNW1/mbJrTO4miqL448BSkP7ZOhUV6HFUpMt3B9HwjiRLN8RORcFp0ID/Azs4Jl/xOpXNzbgQGIffWgCIKTxN9N1ku6tdlG4","encoding":{"content":["pkcs8","sr25519"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"version3","tags":[],"whenCreated":1595277797639,"whenEdited":1595278378596}}';
+    const PASS3 = 'version3';
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 2 });
+    });
+
+    it('can decode from a version 3 JSON file', (): void => {
+      const pair = keyring.addFromJson(JSON.parse(PAIR));
+
+      pair.decodePkcs8(PASS3);
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe('FLiSDPCcJ6auZUGXALLj6jpahcP6adVFDBUQznPXUQ7yoqH');
+    });
+  });
 });

packages/keyring/src/keyring.ts

@@ -3,10 +3,10 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { KeypairType, Keypair } from '@polkadot/util-crypto/types';
-import { KeyringInstance, KeyringPair, KeyringPair$Json, KeyringPair$Meta, KeyringOptions } from './types';
+import { KeyringInstance, KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, KeyringOptions } from './types';
 
-import { assert, hexToU8a, isHex, stringToU8a } from '@polkadot/util';
-import { decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed, mnemonicToMiniSecret } from '@polkadot/util-crypto';
+import { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/util';
+import { base64Decode, decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed, mnemonicToMiniSecret } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
 import createPair from './pair';
@@ -84,10 +84,10 @@ export default class Keyring implements KeyringInstance {
    * 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): KeyringPair {
+  public addFromAddress (address: string | Uint8Array, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, type: KeypairType = this.type, ignoreChecksum?: boolean, encType?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
     const publicKey = this.decodeAddress(address, ignoreChecksum);
 
-    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded));
+    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded, encType));
   }
 
   /**
@@ -97,12 +97,15 @@ export default class Keyring implements KeyringInstance {
    * 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 ({ address, encoded, encoding: { content, version }, meta }: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
-    const type = version === '0' || !Array.isArray(content)
+  public addFromJson ({ address, encoded, encoding: { content, type, version }, meta }: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
+    const cryptoType = version === '0' || !Array.isArray(content)
       ? this.type
       : content[1];
+    const encType = !Array.isArray(type)
+      ? [type]
+      : type;
 
-    return this.addFromAddress(address, meta, hexToU8a(encoded), type, ignoreChecksum);
+    return this.addFromAddress(address, meta, isHex(encoded) ? hexToU8a(encoded) : base64Decode(encoded), cryptoType, ignoreChecksum, encType);
   }
 
   /**
@@ -192,7 +195,7 @@ export default class Keyring implements KeyringInstance {
    * @description Encodes the input into an ss58 representation
    */
   public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
-    return encodeAddress(address, ss58Format || this.#ss58);
+    return encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
   }
 
   /**

packages/keyring/src/pair/decode.ts

@@ -2,11 +2,13 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { assert, stringToU8a, u8aFixLength } from '@polkadot/util';
-import { naclDecrypt } from '@polkadot/util-crypto';
+import { KeyringPair$JsonEncodingTypes } from '../types';
 import { PairInfo } from './types';
 
-import { NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH } from './defaults';
+import { assert, stringToU8a, u8aFixLength } from '@polkadot/util';
+import { naclDecrypt, scryptEncode, scryptFromU8a } from '@polkadot/util-crypto';
+
+import { NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH, SCRYPT_LENGTH } from './defaults';
 
 const SEED_OFFSET = PKCS8_HEADER.length;
 
@@ -41,18 +43,32 @@ function decodePkcs8 (encoded: Uint8Array): DecodeResult {
   };
 }
 
-export default function decode (passphrase?: string, encrypted?: Uint8Array | null): DecodeResult {
+export default function decode (passphrase?: string, encrypted?: Uint8Array | null, encType: KeyringPair$JsonEncodingTypes[] = ['scrypt', 'xsalsa20-poly1305']): DecodeResult {
   assert(encrypted, 'No encrypted data available to decode');
+  assert(passphrase || !encType.includes('xsalsa20-poly1305'), 'Password required to decode encypted data');
 
-  const encoded = passphrase
-    ? naclDecrypt(
+  let encoded: Uint8Array | null = encrypted;
+
+  if (passphrase) {
+    let password: Uint8Array;
+
+    if (encType.includes('scrypt')) {
+      const { params, salt } = scryptFromU8a(encrypted);
+
+      password = scryptEncode(passphrase, salt, params).password;
+      encrypted = encrypted.subarray(SCRYPT_LENGTH);
+    } else {
+      password = stringToU8a(passphrase);
+    }
+
+    encoded = naclDecrypt(
       encrypted.subarray(NONCE_LENGTH),
       encrypted.subarray(0, NONCE_LENGTH),
-      u8aFixLength(stringToU8a(passphrase), 256, true)
-    )
-    : encrypted;
+      u8aFixLength(password, 256, true)
+    );
+  }
 
-  assert(encoded, 'Unable to unencrypt using the supplied passphrase');
+  assert(encoded, 'Unable to decode using the supplied passphrase');
 
   return decodePkcs8(encoded);
 }

packages/keyring/src/pair/defaults.ts

@@ -6,14 +6,18 @@ const NONCE_LENGTH = 24;
 const PKCS8_DIVIDER = new Uint8Array([161, 35, 3, 33, 0]);
 const PKCS8_HEADER = new Uint8Array([48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]);
 const PUB_LENGTH = 32;
+const SALT_LENGTH = 32;
 const SEC_LENGTH = 64;
 const SEED_LENGTH = 32;
+const SCRYPT_LENGTH = SALT_LENGTH + (3 * 4);
 
 export {
   NONCE_LENGTH,
   PKCS8_DIVIDER,
   PKCS8_HEADER,
   PUB_LENGTH,
+  SALT_LENGTH,
   SEC_LENGTH,
-  SEED_LENGTH
+  SEED_LENGTH,
+  SCRYPT_LENGTH
 };

packages/keyring/src/pair/encode.spec.ts

@@ -3,10 +3,10 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import testingPairs from '../testingPairs';
-import { PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH } from './defaults';
+import { PKCS8_DIVIDER, PKCS8_HEADER, NONCE_LENGTH, PUB_LENGTH, SCRYPT_LENGTH, SEC_LENGTH } from './defaults';
 
 const PKCS8_LENGTH = PKCS8_DIVIDER.length + PKCS8_HEADER.length + PUB_LENGTH + SEC_LENGTH;
-const ENCODED_LENGTH = 157;
+const ENCODED_LENGTH = 16 + PKCS8_LENGTH + NONCE_LENGTH + SCRYPT_LENGTH;
 
 const keyring = testingPairs({ type: 'ed25519' }, false);
 

packages/keyring/src/pair/encode.ts

@@ -4,8 +4,8 @@
 
 import { PairInfo } from './types';
 
-import { stringToU8a, u8aConcat, u8aFixLength, assert } from '@polkadot/util';
-import { naclEncrypt } from '@polkadot/util-crypto';
+import { u8aConcat, assert } from '@polkadot/util';
+import { naclEncrypt, scryptEncode, scryptToU8a } from '@polkadot/util-crypto';
 
 import { PKCS8_DIVIDER, PKCS8_HEADER } from './defaults';
 
@@ -23,7 +23,8 @@ export default function encode ({ publicKey, secretKey }: PairInfo, passphrase?:
     return encoded;
   }
 
-  const { encrypted, nonce } = naclEncrypt(encoded, u8aFixLength(stringToU8a(passphrase), 256, true));
+  const { params, password, salt } = scryptEncode(passphrase);
+  const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
 
-  return u8aConcat(nonce, encrypted);
+  return u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
 }

packages/keyring/src/pair/index.ts

@@ -3,7 +3,7 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { Keypair, KeypairType } from '@polkadot/util-crypto/types';
-import { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types';
+import { KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, SignOptions } from '../types';
 import { PairInfo } from './types';
 
 import { assert, u8aConcat } from '@polkadot/util';
@@ -112,7 +112,14 @@ function isLocked (secretKey?: Uint8Array): secretKey is undefined {
  * an `encoded` property that is assigned with the encoded public key in hex format, and an `encoding`
  * property that indicates whether the public key value of the `encoded` property is encoded or not.
  */
-export default function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null): KeyringPair {
+export default function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
+  const recode = (passphrase?: string): Uint8Array => {
+    encoded = encode({ publicKey, secretKey }, passphrase); // re-encode, latest version
+    encTypes = undefined; // swap to defaults, latest version follows
+
+    return encoded;
+  };
+
   return {
     get address (): string {
       return toSS58(getAddress(type, publicKey));
@@ -130,8 +137,8 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
       return type;
     },
     // eslint-disable-next-line sort-keys
-    decodePkcs8: (passphrase?: string, _encoded?: Uint8Array | null): void => {
-      const decoded = decode(passphrase, _encoded || encoded);
+    decodePkcs8: (passphrase?: string, userEncoded?: Uint8Array | null): void => {
+      const decoded = decode(passphrase, userEncoded || encoded, encTypes);
 
       if (decoded.secretKey.length === 64) {
         publicKey = decoded.publicKey;
@@ -152,7 +159,7 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
       return createPair({ toSS58, type }, derived, meta, null);
     },
     encodePkcs8: (passphrase?: string): Uint8Array =>
-      encode({ publicKey, secretKey }, passphrase),
+      recode(passphrase),
     lock: (): void => {
       secretKey = new Uint8Array(0);
     },
@@ -165,7 +172,7 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
       return sign(type, message, { publicKey, secretKey }, options);
     },
     toJson: (passphrase?: string): KeyringPair$Json =>
-      toJson(type, { address: toSS58(getAddress(type, publicKey)), meta }, encode({ publicKey, secretKey }, passphrase), !!passphrase),
+      toJson(type, { address: toSS58(getAddress(type, publicKey)), meta }, recode(passphrase), !!passphrase),
     verify: (message: Uint8Array, signature: Uint8Array): boolean =>
       verify(type, message, signature, publicKey)
   };

packages/keyring/src/pair/toJson.spec.ts

@@ -12,11 +12,11 @@ describe('toJson', (): void => {
       keyring.alice.toJson()
     ).toMatchObject({
       address: '5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua',
-      encoded: '0x3053020101300506032b657004220420416c696365202020202020202020202020202020202020202020202020202020d172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4fa123032100d172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4f',
+      encoded: 'MFMCAQEwBQYDK2VwBCIEIEFsaWNlICAgICAgICAgICAgICAgICAgICAgICAgICAg0XKnTNpMhlkSwyugqApXrmmrrkEOXMtZ3uhOL0Qy20+hIwMhANFyp0zaTIZZEsMroKgKV65pq65BDlzLWd7oTi9EMttP',
       encoding: {
         content: ['pkcs8', 'ed25519'],
-        type: 'none',
-        version: '2'
+        type: ['none'],
+        version: '3'
       },
       meta: {
         isTesting: true,
@@ -28,13 +28,13 @@ describe('toJson', (): void => {
   it('creates an encoded output with passphrase', (): void => {
     const json = keyring.alice.toJson('testing');
 
-    expect(json.encoded).toHaveLength(316);
+    expect(json.encoded).toHaveLength(268);
     expect(json).toMatchObject({
       address: '5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua',
       encoding: {
         content: ['pkcs8', 'ed25519'],
-        type: 'xsalsa20-poly1305',
-        version: '2'
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
       }
     });
   });

packages/keyring/src/pair/toJson.ts

@@ -5,23 +5,26 @@
 import { KeypairType } from '@polkadot/util-crypto/types';
 import { KeyringPair$Json, KeyringPair$Meta } from '../types';
 
-import { u8aToHex } from '@polkadot/util';
+import { base64Encode } from '@polkadot/util-crypto';
 
 interface PairStateJson {
   address: string;
   meta: KeyringPair$Meta;
 }
 
+// version 2 - nonce, encoded (previous)
+// version 3 - salt, nonce, encoded
+
 export default function toJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
   return {
     address,
-    encoded: u8aToHex(encoded),
+    encoded: base64Encode(encoded),
     encoding: {
       content: ['pkcs8', type],
       type: isEncrypted
-        ? 'xsalsa20-poly1305'
-        : 'none',
-      version: '2'
+        ? ['scrypt', 'xsalsa20-poly1305']
+        : ['none'],
+      version: '3'
     },
     meta
   };

packages/keyring/src/types.ts

@@ -12,11 +12,13 @@ export interface KeyringOptions {
 
 export type KeyringPair$Meta = Record<string, unknown>;
 
-export type KeyringPair$JsonVersion = '0' | '1' | '2';
+export type KeyringPair$JsonVersion = '0' | '1' | '2' | '3';
+
+export type KeyringPair$JsonEncodingTypes = 'none' | 'scrypt' | 'xsalsa20-poly1305';
 
 export interface KeyringPair$JsonEncoding {
   content: ['pkcs8', KeypairType];
-  type: 'xsalsa20-poly1305' | 'none';
+  type: KeyringPair$JsonEncodingTypes | KeyringPair$JsonEncodingTypes[];
   version: KeyringPair$JsonVersion;
 }
 

packages/util-crypto/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "2.14.1",
+  "version": "3.1.1",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
   "keywords": [
@@ -25,25 +25,25 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/util": "2.14.1",
-    "@polkadot/wasm-crypto": "^1.2.1",
+    "@babel/runtime": "^7.11.2",
+    "@polkadot/util": "3.1.1",
+    "@polkadot/wasm-crypto": "^1.3.1",
     "base-x": "^3.0.8",
     "bip39": "^3.0.2",
     "blakejs": "^1.1.0",
     "bn.js": "^5.1.2",
-    "bs58": "^4.0.1",
-    "elliptic": "^6.5.2",
+    "elliptic": "^6.5.3",
     "js-sha3": "^0.8.0",
     "pbkdf2": "^3.1.1",
+    "scryptsy": "^2.1.0",
     "tweetnacl": "^1.0.3",
     "xxhashjs": "^0.2.2"
   },
   "devDependencies": {
     "@types/bn.js": "^4.11.6",
-    "@types/bs58": "^4.0.1",
     "@types/elliptic": "^6.4.12",
-    "@types/pbkdf2": "^3.0.0",
+    "@types/pbkdf2": "^3.1.0",
+    "@types/scryptsy": "^2.0.0",
     "@types/xxhashjs": "^0.2.2"
   }
 }

packages/util-crypto/src/address/check.spec.ts

@@ -17,6 +17,12 @@ describe('checkAddress', (): void => {
     ).toEqual([true, null]);
   });
 
+  it('fails when an invalid base58 character is supplied', (): void => {
+    expect(
+      checkAddress('5EnxIUmEbw8DkENKiYuZ1DwQuMoB2UWEQJZZXrTsxoz7SpgG', 2)
+    ).toEqual([false, 'Invalid base58 character "I" (0x49) at index 4']);
+  });
+
   it('fails with invalid prefix when checking Substrate against Kusama prefix', (): void => {
     expect(
       checkAddress('5EnxxUmEbw8DkENKiYuZ1DwQuMoB2UWEQJZZXrTsxoz7SpgG', 2)

packages/util-crypto/src/address/check.ts

@@ -4,13 +4,24 @@
 
 import { Prefix } from './types';
 
-import bs58 from 'bs58';
-
+import base58Decode from '../base58/decode';
 import checkChecksum from './checkChecksum';
 import defaults from './defaults';
 
+/**
+ * @name checkAddress
+ * @summary Validates an ss58 address.
+ * @description
+ * From the provided input, validate that the address is a valid input.
+ */
 export default function check (address: string, prefix: Prefix): [boolean, string | null] {
-  const decoded = bs58.decode(address);
+  let decoded;
+
+  try {
+    decoded = base58Decode(address);
+  } catch (error) {
+    return [false, (error as Error).message];
+  }
 
   if (decoded[0] !== prefix) {
     return [false, `Prefix mismatch, expected ${prefix}, found ${decoded[0]}`];

packages/util-crypto/src/address/decode.spec.ts

@@ -7,7 +7,7 @@ import { stringToU8a, u8aToHex } from '@polkadot/util';
 import testingPairs, { TestKeyringMap } from '../../../keyring/src/testingPairs';
 import decode from './decode';
 
-describe('decode', (): void => {
+describe('decodeAddress', (): void => {
   let keyring: TestKeyringMap;
 
   beforeAll((): void => {
@@ -94,4 +94,10 @@ describe('decode', (): void => {
       (): Uint8Array => decode('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaDwU')
     ).toThrow(/address checksum/);
   });
+
+  it('fails when invalid base58 encoded address is found', (): void => {
+    expect(
+      () => u8aToHex(decode('F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
+    ).toThrow(/Decoding F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29: Invalid base58 character "I" \(0x49\) at index 4/);
+  });
 });

packages/util-crypto/src/address/decode.ts

@@ -6,9 +6,9 @@ import { Prefix } from './types';
 
 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L6
 
-import bs58 from 'bs58';
-import { assert, bufferToU8a, isHex, isU8a, u8aToU8a } from '@polkadot/util';
+import { assert, isHex, isU8a, u8aToU8a } from '@polkadot/util';
 
+import base58Decode from '../base58/decode';
 import checkChecksum from './checkChecksum';
 import defaults from './defaults';
 
@@ -18,11 +18,17 @@ export default function decode (encoded: string | Uint8Array, ignoreChecksum?: b
     return u8aToU8a(encoded);
   }
 
-  const decoded = bufferToU8a(bs58.decode(encoded));
-  const error = (message: string) => `Decoding ${encoded as string}: ${message}`;
+  const wrapError = (message: string) => `Decoding ${encoded as string}: ${message}`;
+  let decoded;
+
+  try {
+    decoded = base58Decode(encoded);
+  } catch (error) {
+    throw new Error(wrapError((error as Error).message));
+  }
 
   // assert(defaults.allowedPrefix.includes(decoded[0] as Prefix), error('Invalid decoded address prefix'));
-  assert(defaults.allowedEncodedLengths.includes(decoded.length), error('Invalid decoded address length'));
+  assert(defaults.allowedEncodedLengths.includes(decoded.length), wrapError('Invalid decoded address length'));
 
   // TODO Unless it is an "use everywhere" prefix, throw an error
   // if (decoded[0] !== prefix) {
@@ -31,7 +37,7 @@ export default function decode (encoded: string | Uint8Array, ignoreChecksum?: b
 
   const [isValid, endPos] = checkChecksum(decoded);
 
-  assert(ignoreChecksum || isValid, error('Invalid decoded address checksum'));
+  assert(ignoreChecksum || isValid, wrapError('Invalid decoded address checksum'));
 
   return decoded.slice(1, endPos);
 }

packages/util-crypto/src/address/derive.spec.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { waitReady } from '@polkadot/wasm-crypto';
+
+import derive from './derive';
+
+describe('deriveAddress', (): void => {
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  it('derives a known path', (): void => {
+    expect(
+      derive('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '/joe/polkadot/0')
+    ).toEqual('5GZ4srnepXvdsuNVoxCGyVZd8ScDm4gkGLTKuaGARy9akjTa');
+  });
+
+  it('fails on hard paths', (): void => {
+    expect(
+      () => derive('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '//bob')
+    ).toThrow(/Expected suri to contain a combination of non-hard paths/);
+  });
+});

packages/util-crypto/src/address/derive.ts

@@ -0,0 +1,29 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 './types';
+
+import { assert } from '@polkadot/util';
+
+import DeriveJunction from '../key/DeriveJunction';
+import { keyExtractPath } from '../key';
+import { schnorrkelDerivePublic } from '../schnorrkel';
+import decode from './decode';
+import encode from './encode';
+
+/**
+ * @name deriveAddress
+ * @summary Creates a sr25519 derived address from the supplied and path.
+ * @description
+ * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
+ */
+export default function deriveAddress (who: Uint8Array | string, suri: string, ss58Format?: Prefix): string {
+  const { path } = keyExtractPath(suri);
+
+  assert(path.length && !path.some((path) => path.isHard), 'Expected suri to contain a combination of non-hard paths');
+
+  return encode(path.reduce((publicKey: Uint8Array, path: DeriveJunction): Uint8Array => {
+    return schnorrkelDerivePublic(publicKey, path.chainCode);
+  }, decode(who)), ss58Format);
+}

packages/util-crypto/src/address/encode.spec.ts

@@ -21,6 +21,12 @@ describe('encode', (): void => {
     ).toEqual('7sL6eNJj5ZGV5cn3hhV2deRUsivXfBfMH76wCALCqWj1EKzv');
   });
 
+  it('can re-encode an address to Polkadot live', (): void => {
+    expect(
+      encode('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 0)
+    ).toEqual('15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5');
+  });
+
   it('fails when non-valid publicKey provided', (): void => {
     expect(
       (): string => encode(

packages/util-crypto/src/address/encode.ts

@@ -6,9 +6,9 @@ import { Prefix } from './types';
 
 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L34
 
-import bs58 from 'bs58';
-import { assert, u8aConcat, u8aToBuffer } from '@polkadot/util';
+import { assert, u8aConcat } from '@polkadot/util';
 
+import base58Encode from '../base58/encode';
 import decode from './decode';
 import defaults from './defaults';
 import sshash from './sshash';
@@ -23,9 +23,7 @@ export default function encode (_key: Uint8Array | string, ss58Format: Prefix =
   const input = u8aConcat(new Uint8Array([ss58Format]), key);
   const hash = sshash(input);
 
-  return bs58.encode(
-    u8aToBuffer(
-      u8aConcat(input, hash.subarray(0, isPublicKey ? 2 : 1))
-    )
+  return base58Encode(
+    u8aConcat(input, hash.subarray(0, isPublicKey ? 2 : 1))
   );
 }

packages/util-crypto/src/address/encodeDerived.spec.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 encodeDerivedAddress from './encodeDerived';
+
+describe('encodeDerivedAddress', (): void => {
+  it('creates a valid known derived address', (): void => {
+    expect(
+      encodeDerivedAddress('5GvUh7fGKsdBEh5XpypkfkGuf7j3vXLxH9BdxjxnJNVXRYi1', 0)
+    ).toEqual('5E5XxqPxm7QbEs6twYfp3tyjXidn4kqRrNPH4o6JK9JSLUeD');
+  });
+});

packages/util-crypto/src/address/encodeDerived.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 './types';
+
+import BN from 'bn.js';
+
+import decode from './decode';
+import encode from './encode';
+import keyDerived from './keyDerived';
+
+/**
+ * @name encodeDerivedAddress
+ * @summary Creates a derived address as used in Substrate utility.
+ * @description
+ * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
+ */
+export default function encodeDerivedAddress (who: Uint8Array | string, index: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encode(keyDerived(decode(who), index), ss58Format);
+}

packages/util-crypto/src/address/encodeMulti.spec.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 encodeMultiAddress from './encodeMulti';
+
+describe('encodeMultiAddress', (): void => {
+  it('creates a valid known multi address', (): void => {
+    expect(
+      encodeMultiAddress([
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
+        '5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y'
+      ], 2)
+    ).toEqual('5DjYJStmdZ2rcqXbXGX7TW85JsrW6uG4y9MUcLq2BoPMpRA7');
+  });
+});

packages/util-crypto/src/address/encodeMulti.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 './types';
+
+import BN from 'bn.js';
+
+import encode from './encode';
+import keyMulti from './keyMulti';
+
+/**
+ * @name encodeMultiAddress
+ * @summary Creates a multisig address.
+ * @description
+ * Creates a Substrate multisig address based on the input address and the required threshold.
+ */
+export default function encodeMultiAddress (who: (Uint8Array | string)[], threshold: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encode(keyMulti(who, threshold), ss58Format);
+}

packages/util-crypto/src/address/index.ts

@@ -5,9 +5,12 @@
 import checkAddress from './check';
 import checkAddressChecksum from './checkChecksum';
 import createKeyMulti from './keyMulti';
-import createKeySub from './keySub';
+import createKeyDerived from './keyDerived';
 import decodeAddress from './decode';
+import deriveAddress from './derive';
 import encodeAddress from './encode';
+import encodeDerivedAddress from './encodeDerived';
+import encodeMultiAddress from './encodeMulti';
 import addressEq from './eq';
 import setSS58Format from './setSS58Format';
 import sortAddresses from './sort';
@@ -16,10 +19,13 @@ export {
   addressEq,
   checkAddress,
   checkAddressChecksum,
+  createKeyDerived,
   createKeyMulti,
-  createKeySub,
   decodeAddress,
+  deriveAddress,
   encodeAddress,
+  encodeDerivedAddress,
+  encodeMultiAddress,
   setSS58Format,
   sortAddresses
 };

packages/util-crypto/src/address/keyDerived.spec.ts

@@ -2,12 +2,12 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import createKeySub from './keySub';
+import createKeyDerived from './keyDerived';
 
-describe('createKeySub', (): void => {
+describe('createKeyDerived', (): void => {
   it('matches sub accounts with Rust', (): void => {
     expect(
-      createKeySub(new Uint8Array([1, 0, 0, 0, 0, 0, 0, 0]), 0)
+      createKeyDerived(new Uint8Array([1, 0, 0, 0, 0, 0, 0, 0]), 0)
     ).toEqual(
       new Uint8Array([234, 236, 28, 96, 177, 168, 152, 193, 71, 179, 226, 102, 179, 155, 188, 240, 90, 182, 21, 175, 47, 47, 250, 179, 178, 0, 81, 222, 70, 56, 52, 234])
     );
@@ -15,7 +15,7 @@ describe('createKeySub', (): void => {
 
   it('creates a valid subkey', (): void => {
     expect(
-      createKeySub('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 1)
+      createKeyDerived('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 1)
     ).toEqual(
       new Uint8Array([248, 19, 86, 209, 254, 89, 84, 48, 54, 128, 166, 239, 153, 212, 143, 34, 191, 60, 210, 50, 39, 77, 122, 71, 29, 60, 247, 198, 95, 101, 246, 83])
     );

packages/util-crypto/src/address/keyDerived.ts

@@ -10,7 +10,7 @@ import decodeAddress from './decode';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export default function createKeySub (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
+export default function createKeyDerived (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,

packages/util-crypto/src/address/ss58.ts

@@ -7,6 +7,8 @@ export const allowedSS58 = [
   0, 1,
   // Kusama
   2, 3,
+  // Katal Chain
+  4,
   // Kulupu
   16, 17,
   // Dothereum

packages/util-crypto/src/base32/bs32.ts

@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+// https://github.com/multiformats/js-multibase/blob/master/src/constants.js
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+const BITS_PER_CHAR = 5;
+
+export {
+  BASE32_ALPHABET,
+  BITS_PER_CHAR
+};

packages/util-crypto/src/base32/decode.spec.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { u8aToString } from '@polkadot/util';
+
+import { base32Decode } from './';
+
+describe('base32Decode', (): void => {
+  it('decodes a base32', (): void => {
+    expect(
+      u8aToString(
+        base32Decode('irswgzloorzgc3djpjssazlwmvzhs5dinfxgoijb')
+      )
+    ).toEqual('Decentralize everything!!');
+  });
+
+  it('decodes a base32 (ipfsCompat)', (): void => {
+    expect(
+      u8aToString(
+        base32Decode('birswgzloorzgc3djpjssazlwmvzhs5dinfxgoijb', true)
+      )
+    ).toEqual('Decentralize everything!!');
+  });
+});

packages/util-crypto/src/base32/decode.ts

@@ -0,0 +1,54 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+// adapted from https://github.com/multiformats/js-multibase/blob/424709195b46ffb1d6f2f69a7707598ebe751e5e/src/rfc4648.js
+
+import { assert } from '@polkadot/util';
+
+import { BASE32_ALPHABET, BITS_PER_CHAR } from './bs32';
+import validate from './validate';
+
+// Build the character lookup table:
+const LOOKUP = BASE32_ALPHABET
+  .split('')
+  .reduce((lookup: Record<string, number>, char: string, index: number): Record<string, number> => {
+    lookup[char] = index;
+
+    return lookup;
+  }, {});
+
+/**
+ * @name base32Decode
+ * @summary Delookup a base32 value.
+ * @description
+ * From the provided input, decode the base32 and return the result as an `Uint8Array`.
+ */
+export default function base32Decode (value: string, ipfsCompat = false): Uint8Array {
+  if (ipfsCompat) {
+    assert(value[0] === 'b', "Expected IPFS base32 identifier 'b' at string start");
+
+    value = value.substr(1);
+  }
+
+  validate(value);
+
+  const out = new Uint8Array((value.length * BITS_PER_CHAR / 8) | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+
+  for (let i = 0; i < value.length; ++i) {
+    buffer = (buffer << BITS_PER_CHAR) | LOOKUP[value[i]];
+    bits += BITS_PER_CHAR;
+
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 0xff & (buffer >> bits);
+    }
+  }
+
+  assert(!(bits >= BITS_PER_CHAR || 0xff & (buffer << (8 - bits))), 'Unexpected end of data');
+
+  return out;
+}

packages/util-crypto/src/base32/encode.spec.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { base58Decode } from '../base58';
+import { base32Encode } from './';
+
+describe('base32Encode', (): void => {
+  it('encodes to a base32', (): void => {
+    expect(
+      base32Encode('Decentralize everything!!')
+    ).toEqual('irswgzloorzgc3djpjssazlwmvzhs5dinfxgoijb');
+  });
+
+  it('encodes a base58 to a base32', (): void => {
+    expect(
+      base32Encode(
+        base58Decode('zb2rhk6GMPQF3hfzwXTaNYFLKomMeC6UXdUt6jZKPpeVirLtV', true),
+        true
+      )
+    ).toEqual('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy');
+  });
+});

packages/util-crypto/src/base32/encode.ts

@@ -0,0 +1,42 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+// adapted from https://github.com/multiformats/js-multibase/blob/424709195b46ffb1d6f2f69a7707598ebe751e5e/src/rfc4648.js
+
+import { u8aToU8a } from '@polkadot/util';
+
+import { BASE32_ALPHABET, BITS_PER_CHAR } from './bs32';
+
+const MASK = (1 << BITS_PER_CHAR) - 1;
+
+/**
+ * @name base32Encode
+ * @summary Creates a base32 value.
+ * @description
+ * From the provided input, create the base32 and return the result as a string.
+ */
+export default function base32Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat = false): string {
+  const u8a = u8aToU8a(value);
+  let out = '';
+  let bits = 0;
+  let buffer = 0;
+
+  for (let i = 0; i < u8a.length; ++i) {
+    buffer = (buffer << 8) | u8a[i];
+    bits += 8;
+
+    while (bits > BITS_PER_CHAR) {
+      bits -= BITS_PER_CHAR;
+      out += BASE32_ALPHABET[MASK & (buffer >> bits)];
+    }
+  }
+
+  if (bits) {
+    out += BASE32_ALPHABET[MASK & (buffer << (BITS_PER_CHAR - bits))];
+  }
+
+  return ipfsCompat
+    ? `b${out}`
+    : out;
+}

packages/util-crypto/src/base32/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+/**
+ * @summary Encode and decode base32 values
+ */
+
+export { default as base32Decode } from './decode';
+export { default as base32Encode } from './encode';
+export { default as base32Validate } from './validate';

packages/util-crypto/src/base32/validate.ts

@@ -0,0 +1,16 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { validateChars } from '../base58/validate';
+import { BASE32_ALPHABET } from './bs32';
+
+/**
+ * @name base32Validate
+ * @summary Validates a base32 value.
+ * @description
+ * Validates the the supplied value is valid base32
+ */
+export default function base32Validate (value: string): true {
+  return validateChars('base32', BASE32_ALPHABET, value);
+}

packages/util-crypto/src/base58/bs58.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 baseX from 'base-x';
+
+// https://github.com/cryptocoinjs/base-x#alphabets
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+const bs58 = baseX(BASE58_ALPHABET);
+
+export {
+  BASE58_ALPHABET,
+  bs58
+};

packages/util-crypto/src/base58/decode.ts

@@ -0,0 +1,26 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { assert, bufferToU8a } from '@polkadot/util';
+
+import { bs58 } from './bs58';
+import validate from './validate';
+
+/**
+ * @name base58Decode
+ * @summary Decodes a base58 value.
+ * @description
+ * From the provided input, decode the base58 and return the result as an `Uint8Array`.
+ */
+export default function base58Decode (value: string, ipfsCompat = false): Uint8Array {
+  if (ipfsCompat) {
+    assert(value[0] === 'z', "Expected IPFS base32 identifier 'z' at string start");
+
+    value = value.substr(1);
+  }
+
+  validate(value);
+
+  return bufferToU8a(bs58.decode(value));
+}

packages/util-crypto/src/base58/encode.spec.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { base32Decode } from '../base32';
+import { base58Encode } from './';
+
+describe('base58Encode', (): void => {
+  it('encodes a base32 to a base38', (): void => {
+    expect(
+      base58Encode(
+        base32Decode('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true),
+        true
+      )
+    ).toEqual('zb2rhk6GMPQF3hfzwXTaNYFLKomMeC6UXdUt6jZKPpeVirLtV');
+  });
+});

packages/util-crypto/src/base58/encode.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { u8aToBuffer, u8aToU8a } from '@polkadot/util';
+
+import { bs58 } from './bs58';
+
+/**
+ * @name base58Encode
+ * @summary Creates a base58 value.
+ * @description
+ * From the provided input, create the base58 and return the result as a string.
+ */
+export default function base58Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat = false): string {
+  const out = bs58.encode(
+    u8aToBuffer(u8aToU8a(value))
+  );
+
+  return ipfsCompat
+    ? `z${out}`
+    : out;
+}

packages/util-crypto/src/base58/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+/**
+ * @summary Encode and decode base58 values
+ */
+
+export { default as base58Decode } from './decode';
+export { default as base58Encode } from './encode';
+export { default as base58Validate } from './validate';

packages/util-crypto/src/base58/validate.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { BASE58_ALPHABET } from './bs58';
+
+export function validateChars (type: string, alphabet: string, value: string): true {
+  for (let i = 0; i < value.length; i++) {
+    if (!alphabet.includes(value[i])) {
+      throw new TypeError(`Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
+    }
+  }
+
+  return true;
+}
+
+/**
+ * @name base58Validate
+ * @summary Validates a base58 value.
+ * @description
+ * Validates the the supplied value is valid base58
+ */
+export default function base58Validate (value: string): true {
+  return validateChars('base58', BASE58_ALPHABET, value);
+}

packages/util-crypto/src/base64/decode.spec.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { stringToU8a } from '@polkadot/util';
+
+import { base64Decode } from '.';
+
+describe('base64Decode', (): void => {
+  it('decodes a mixed base64 utf8 string', (): void => {
+    expect(
+      base64Decode('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toEqual(
+      stringToU8a('hello world Приветствую ми 你好')
+    );
+  });
+});

packages/util-crypto/src/base64/decode.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { bufferToU8a } from '@polkadot/util';
+
+import validate from './validate';
+
+/**
+ * @name base64Decode
+ * @summary Decodes a base64 value.
+ * @description
+ * From the provided input, decode the base64 and return the result as an `Uint8Array`.
+ */
+export default function base64Decode (value: string): Uint8Array {
+  validate(value);
+
+  return bufferToU8a(Buffer.from(value, 'base64'));
+}

packages/util-crypto/src/base64/encode.spec.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { base64Encode } from '.';
+
+describe('base64Encode', (): void => {
+  it('encodes a mixed base64 utf8 string', (): void => {
+    expect(
+      base64Encode('hello world Приветствую ми 你好')
+    ).toEqual('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==');
+  });
+});

packages/util-crypto/src/base64/encode.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { u8aToBuffer, u8aToU8a } from '@polkadot/util';
+
+/**
+ * @name base64Encode
+ * @summary Creates a base64 value.
+ * @description
+ * From the provided input, create the base64 and return the result as a string.
+ */
+export default function base58Encode (value: Uint8Array | string | Buffer | number[]): string {
+  return u8aToBuffer(u8aToU8a(value)).toString('base64');
+}

packages/util-crypto/src/base64/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+/**
+ * @summary Encode and decode base64 values
+ */
+
+export { default as base64Decode } from './decode';
+export { default as base64Encode } from './encode';
+export { default as base64Validate } from './validate';

packages/util-crypto/src/base64/validate.spec.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { base64Validate } from '.';
+
+describe('base64Validate', (): void => {
+  it('decodes a mixed base64 utf8 string', (): void => {
+    expect(
+      () => base64Validate('aGVsbG8gd29ybGQg0J/RgNC40LLQtd^GC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toThrow(/Invalid base64 encoding/);
+  });
+});

packages/util-crypto/src/base64/validate.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+/**
+ * @name base64Validate
+ * @summary Validates a base64 value.
+ * @description
+ * Validates the the supplied value is valid base64
+ */
+export default function base64Validate (value: string): true {
+  if (!(/^(?:[A-Za-z0-9+/]{2}[A-Za-z0-9+/]{2})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))) {
+    throw new TypeError('Invalid base64 encoding');
+  }
+
+  return true;
+}

packages/util-crypto/src/index.ts

@@ -10,13 +10,17 @@ export * from './init';
 
 // all internal exports
 export * from './address';
+export * from './base58';
+export * from './base64';
 export * from './blake2';
 export * from './keccak';
 export * from './key';
 export * from './mnemonic';
 export * from './nacl';
+export * from './pbkdf2';
 export * from './random';
 export * from './schnorrkel';
+export * from './scrypt';
 export * from './secp256k1';
 export * from './sha512';
 export * from './signature';

packages/util-crypto/src/key/extractSuri.spec.ts

@@ -8,7 +8,7 @@ describe('keyExtractSuri', (): void => {
   it('does not extract from invalid suri', (): void => {
     expect(
       (): ExtractResult => keyExtractSuri('//2')
-    ).toThrow(/to a secret URI/);
+    ).toThrow('Unable to match provided value to a secret URI');
   });
 
   it('derives on "hello world"', (): void => {

packages/util-crypto/src/key/extractSuri.ts

@@ -22,7 +22,7 @@ export default function keyExtract (suri: string): ExtractResult {
   // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
   const matches = suri.match(RE_CAPTURE);
 
-  assert(!isNull(matches), `Unable to match '${suri}' to a secret URI`);
+  assert(!isNull(matches), 'Unable to match provided value to a secret URI');
 
   const [, phrase, , derivePath, , , password] = matches as string[];
   const { path } = keyExtractPath(derivePath);

packages/util-crypto/src/pbkdf2/encode.ts

@@ -0,0 +1,24 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { pbkdf2Sync } from 'pbkdf2';
+import { bufferToU8a, u8aToBuffer, u8aToU8a } from '@polkadot/util';
+import { isReady, pbkdf2 } from '@polkadot/wasm-crypto';
+
+import randomAsU8a from '../random/asU8a';
+
+interface Result {
+  password: Uint8Array;
+  rounds: number;
+  salt: Uint8Array;
+}
+
+export default function pbkdf2Encode (passphrase?: Uint8Array | string, salt = randomAsU8a(), rounds = 2048): Result {
+  const u8a = u8aToU8a(passphrase);
+  const password = isReady()
+    ? pbkdf2(u8a, salt, rounds)
+    : bufferToU8a(pbkdf2Sync(u8aToBuffer(u8a), u8aToBuffer(salt), rounds, 64));
+
+  return { password, rounds, salt };
+}

packages/util-crypto/src/pbkdf2/index.ts

@@ -0,0 +1,5 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+export { default as pbkdf2Encode } from './encode';

packages/util-crypto/src/schnorrkel/derivePublic.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 '../polyfill';
+
+import { sr25519DerivePublicSoft } from '@polkadot/wasm-crypto';
+
+export default function deriveSoft (publicKey: Uint8Array, chainCode: Uint8Array): Uint8Array {
+  return sr25519DerivePublicSoft(publicKey, chainCode);
+}

packages/util-crypto/src/schnorrkel/index.ts

@@ -5,6 +5,7 @@
 import '../polyfill';
 
 export { default as schnorrkelDeriveHard } from './deriveHard';
+export { default as schnorrkelDerivePublic } from './derivePublic';
 export { default as schnorrkelDeriveSoft } from './deriveSoft';
 export { default as schnorrkelKeypairFromSeed } from './keypair/fromSeed';
 export { default as schnorrkelSign } from './sign';

packages/util-crypto/src/scrypt/defaults.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+const DEFAULT_PARAMS = {
+  N: 1 << 15,
+  p: 1,
+  r: 8
+};
+
+export { DEFAULT_PARAMS };

packages/util-crypto/src/scrypt/encode.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { Params } from './types';
+
+import scryptsy from 'scryptsy';
+import { bufferToU8a, u8aToBuffer, u8aToU8a } from '@polkadot/util';
+import { isReady, scrypt } from '@polkadot/wasm-crypto';
+
+import randomAsU8a from '../random/asU8a';
+import { DEFAULT_PARAMS } from './defaults';
+
+interface Result {
+  params: Params,
+  password: Uint8Array;
+  salt: Uint8Array;
+}
+
+export default function scryptEncode (passphrase?: Uint8Array | string, salt = randomAsU8a(), params = DEFAULT_PARAMS): Result {
+  const password = isReady()
+    ? scrypt(u8aToU8a(passphrase), salt, Math.log2(params.N), params.r, params.p)
+    : bufferToU8a(
+      scryptsy(u8aToBuffer(u8aToU8a(passphrase)), u8aToBuffer(salt), params.N, params.r, params.p, 64)
+    );
+
+  return { params, password, salt };
+}

packages/util-crypto/src/scrypt/fromU8a.ts

@@ -0,0 +1,29 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { Params } from './types';
+
+import { u8aToBn, assert } from '@polkadot/util';
+
+import { DEFAULT_PARAMS } from './defaults';
+
+interface Result {
+  params: Params,
+  salt: Uint8Array;
+}
+
+export default function scryptFromU8a (data: Uint8Array): Result {
+  const salt = data.subarray(0, 32);
+  const N = u8aToBn(data.subarray(32 + 0, 32 + 4), { isLe: true }).toNumber();
+  const p = u8aToBn(data.subarray(32 + 4, 32 + 8), { isLe: true }).toNumber();
+  const r = u8aToBn(data.subarray(32 + 8, 32 + 12), { isLe: true }).toNumber();
+
+  // FIXME At this moment we assume these to be fixed params, this is not a great idea since we lose flexibility
+  // and updates for greater security. However we need some protection against carefully-crafted params that can
+  // eat up CPU since these are user inputs. So we need to get very clever here, but atm we only allow the defaults
+  // and if no match, bail out
+  assert(N === DEFAULT_PARAMS.N && p === DEFAULT_PARAMS.p && r === DEFAULT_PARAMS.r, 'Invalid injected scrypt params found');
+
+  return { params: { N, p, r }, salt };
+}

packages/util-crypto/src/scrypt/index.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+export { default as scryptEncode } from './encode';
+export { default as scryptFromU8a } from './fromU8a';
+export { default as scryptToU8a } from './toU8a';

packages/util-crypto/src/scrypt/toU8a.ts

@@ -0,0 +1,16 @@
+// Copyright 2017-2020 @polkadot/util-crypto 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 { Params } from './types';
+
+import { bnToU8a, u8aConcat } from '@polkadot/util';
+
+export default function scryptToU8a (salt: Uint8Array, { N, p, r }: Params): Uint8Array {
+  return u8aConcat(
+    salt,
+    bnToU8a(N, { bitLength: 32, isLe: true }),
+    bnToU8a(p, { bitLength: 32, isLe: true }),
+    bnToU8a(r, { bitLength: 32, isLe: true })
+  );
+}

packages/util-crypto/src/scrypt/types.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+export interface Params {
+  N: number;
+  p: number;
+  r: number;
+}

packages/util/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util",
-  "version": "2.14.1",
+  "version": "3.1.1",
   "description": "A collection of useful utilities for @polkadot",
   "main": "index.js",
   "keywords": [
@@ -25,7 +25,7 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
+    "@babel/runtime": "^7.11.2",
     "@types/bn.js": "^4.11.6",
     "bn.js": "^5.1.2",
     "camelcase": "^5.3.1",

packages/util/src/is/ascii.spec.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2020 @polkadot/util 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 { isAscii } from '.';
+
+describe('isAscii', (): void => {
+  it('returns true for an ASCII string', (): void => {
+    expect(isAscii('Hello\tWorld!\n\rTesting')).toEqual(true);
+  });
+
+  it('returns true for ASCII bytes', (): void => {
+    expect(isAscii(new Uint8Array([0x31, 0x32, 0x20, 10]))).toEqual(true);
+  });
+
+  it('returns true for empty string inputs', (): void => {
+    expect(isAscii('')).toEqual(true);
+  });
+
+  it('returns true for empty U8a inputs', (): void => {
+    expect(isAscii(new Uint8Array())).toEqual(true);
+  });
+
+  it('returns false for empty undefined inputs', (): void => {
+    expect(isAscii()).toEqual(false);
+  });
+
+  it('returns false for non-printable characters', (): void => {
+    expect(isAscii(new Uint8Array([5]))).toEqual(false);
+  });
+});

packages/util/src/is/ascii.ts

@@ -0,0 +1,24 @@
+// Copyright 2017-2020 @polkadot/util 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 u8aToU8a from '../u8a/toU8a';
+import isString from './string';
+
+const FORMAT = [9, 10, 13];
+
+/**
+ * @name isAscii
+ * @summary Tests if the input is printable ASCII
+ * @description
+ * Checks to see if the input string or Uint8Array is printable ASCII, 32-127 + formatters
+ */
+export default function isAscii (value?: number[] | Buffer | Uint8Array | string | null): boolean {
+  if (!value) {
+    return isString(value);
+  }
+
+  const u8a = u8aToU8a(value);
+
+  return !u8a.some((byte) => (byte >= 127) || (byte < 32 && !FORMAT.includes(byte)));
+}

packages/util/src/is/index.ts

@@ -5,6 +5,7 @@
 /**
  * @summary Type checking utilities
  */
+export { default as isAscii } from './ascii';
 export { default as isBigInt } from './bigInt';
 export { default as isBn } from './bn';
 export { default as isBuffer } from './buffer';
@@ -25,3 +26,4 @@ export { default as isTestChain } from './testChain';
 export { default as isToBn } from './toBn';
 export { default as isU8a } from './u8a';
 export { default as isUndefined } from './undefined';
+export { default as isUtf8 } from './utf8';

packages/util/src/is/utf8.spec.ts

@@ -0,0 +1,41 @@
+// Copyright 2017-2020 @polkadot/util 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 { isUtf8 } from '.';
+
+describe('isUtf8', (): void => {
+  it('returns true for an ASCII string', (): void => {
+    expect(isUtf8('Hello\tWorld!\n\rTesting')).toEqual(true);
+  });
+
+  it('returns true for ASCII bytes', (): void => {
+    expect(isUtf8(new Uint8Array([0x31, 0x32, 0x20, 10]))).toEqual(true);
+  });
+
+  it('returns true for empty string inputs', (): void => {
+    expect(isUtf8('')).toEqual(true);
+  });
+
+  it('returns true for empty U8a inputs', (): void => {
+    expect(isUtf8(new Uint8Array())).toEqual(true);
+  });
+
+  it('returns false for empty undefined inputs', (): void => {
+    expect(isUtf8()).toEqual(false);
+  });
+
+  it('it is valid for ru', (): void => {
+    expect(isUtf8('Приветствую, ми')).toEqual(true);
+  });
+
+  it('is valid for zh', (): void => {
+    expect(isUtf8('你好')).toEqual(true);
+  });
+
+  it('is invalid for something random', (): void => {
+    expect(isUtf8('0x7f07b1f87709608bee603bbc79a0dfc29cd315c1351a83aa31adf7458d7d3003')).toEqual(false);
+    expect(isUtf8('0xc9ec51351beec59b52db06b3dd4685004013035df080358c319553ced597ca05')).toEqual(false);
+    expect(isUtf8('0xd12cef06e90a05b63737d542aaee1389ff9f5c25e461b362180f025c3b2d5635')).toEqual(false);
+  });
+});

packages/util/src/is/utf8.ts

@@ -0,0 +1,208 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+// Adapted from https://github.com/JulienPalard/is_utf8/blob/master/is_utf8.c
+
+import u8aToU8a from '../u8a/toU8a';
+import isString from './string';
+
+/**
+ * @name isUtf8
+ * @summary Tests if the input is valid Utf8
+ * @description
+ * Checks to see if the input string or Uint8Array is valid Utf8
+ */
+export default function isUtf8 (value?: number[] | Buffer | Uint8Array | string | null): boolean {
+  if (!value) {
+    return isString(value);
+  }
+
+  const u8a = u8aToU8a(value);
+  const len = u8a.length;
+  let i = 0;
+
+  while (i < len) {
+    if (u8a[i] <= 0x7F) /* 00..7F */ {
+      i += 1;
+    } else if (u8a[i] >= 0xC2 && u8a[i] <= 0xDF) /* C2..DF 80..BF */ {
+      if (i + 1 < len) /* Expect a 2nd byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte between C2 and DF, expecting a 2nd byte between 80 and BF";
+          // *faulty_bytes = 2;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte between C2 and DF, expecting a 2nd byte.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 2;
+    } else if (u8a[i] === 0xE0) /* E0 A0..BF 80..BF */ {
+      if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+        if (u8a[i + 1] < 0xA0 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte of E0, expecting a 2nd byte between A0 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of E0, expecting a 3nd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of E0, expecting two following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 3;
+    } else if (u8a[i] >= 0xE1 && u8a[i] <= 0xEC) /* E1..EC 80..BF 80..BF */ {
+      if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte between E1 and EC, expecting the 2nd byte between 80 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte between E1 and EC, expecting the 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte between E1 and EC, expecting two following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 3;
+    } else if (u8a[i] === 0xED) /* ED 80..9F 80..BF */ {
+      if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x9F) {
+          // *message = "After a first byte of ED, expecting 2nd byte between 80 and 9F.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of ED, expecting 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of ED, expecting two following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 3;
+    } else if (u8a[i] >= 0xEE && u8a[i] <= 0xEF) /* EE..EF 80..BF 80..BF */ {
+      if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte between EE and EF, expecting 2nd byte between 80 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte between EE and EF, expecting 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte between EE and EF, two following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 3;
+    } else if (u8a[i] === 0xF0) /* F0 90..BF 80..BF 80..BF */ {
+      if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+        if (u8a[i + 1] < 0x90 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte of F0, expecting 2nd byte between 90 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of F0, expecting 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+
+        if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+          // *message = "After a first byte of F0, expecting 4th byte between 80 and BF.";
+          // *faulty_bytes = 4;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of F0, expecting three following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 4;
+    } else if (u8a[i] >= 0xF1 && u8a[i] <= 0xF3) /* F1..F3 80..BF 80..BF 80..BF */ {
+      if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte of F1, F2, or F3, expecting a 2nd byte between 80 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of F1, F2, or F3, expecting a 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+
+        if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+          // *message = "After a first byte of F1, F2, or F3, expecting a 4th byte between 80 and BF.";
+          // *faulty_bytes = 4;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of F1, F2, or F3, expecting three following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 4;
+    } else if (u8a[i] === 0xF4) /* F4 80..8F 80..BF 80..BF */ {
+      if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x8F) {
+          // *message = "After a first byte of F4, expecting 2nd byte between 80 and 8F.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of F4, expecting 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+
+        if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+          // *message = "After a first byte of F4, expecting 4th byte between 80 and BF.";
+          // *faulty_bytes = 4;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of F4, expecting three following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 4;
+    } else {
+      // *message = "Expecting bytes in the following ranges: 00..7F C2..F4.";
+      // *faulty_bytes = 1;
+      return false;
+    }
+  }
+
+  return true;
+}

packages/util/src/number/toU8a.spec.ts

@@ -5,12 +5,6 @@
 import { numberToU8a } from '.';
 
 describe('numberToU8a', (): void => {
-  it('converts 0 to empty', (): void => {
-    expect(
-      numberToU8a(0)
-    ).toEqual(new Uint8Array());
-  });
-
   it('converts undefined to empty', (): void => {
     expect(
       numberToU8a()
@@ -29,6 +23,18 @@ describe('numberToU8a', (): void => {
     ).toEqual(new Uint8Array());
   });
 
+  it('converts 0 to u8a', (): void => {
+    expect(
+      numberToU8a(0)
+    ).toEqual(new Uint8Array([0]));
+  });
+
+  it('converts 0 to u8a (with length)', (): void => {
+    expect(
+      numberToU8a(0, 16)
+    ).toEqual(new Uint8Array([0, 0]));
+  });
+
   it('converts values to the u8a', (): void => {
     expect(
       numberToU8a(0x3456)

packages/util/src/number/toU8a.ts

@@ -3,6 +3,8 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import hexToU8a from '../hex/toU8a';
+import isNull from '../is/null';
+import isUndefined from '../is/undefined';
 import numberToHex from './toHex';
 
 /**
@@ -20,7 +22,7 @@ import numberToHex from './toHex';
  * ```
  */
 export default function numberToU8a (value?: number | null, bitLength = -1): Uint8Array {
-  if (!value || isNaN(value)) {
+  if (isUndefined(value) || isNull(value) || isNaN(value)) {
     return new Uint8Array();
   }